### Available methods
offset, hide, show, first, last, get, eq, on, off, html, text, val, css, attr,
data, rmAttr, remove, addClass, rmClass, toggleClass, hasClass, append, prepend,
before, after
```javascript
const $btn = $('#btn');
$btn.html('eustia');
$btn.addClass('btn');
$btn.show();
$btn.on('click', function() {
// Do something...
});
```
## \$attr
Element attribute manipulation.
Type Definition
namespace $attr {
function remove(element: $safeEls.El, name: string): void;
}
function $attr(
element: $safeEls.El,
name: string,
value: string
): void;
function $attr(
element: $safeEls.El,
attributes: types.PlainObj<string>
): void;
function $attr(element: $safeEls.El, name: string): string;
Get the value of an attribute for the first element in the set of matched elements.
| Name | Desc |
| ------- | -------------------------------- |
| element | Elements to manipulate |
| name | Attribute name |
| return | Attribute value of first element |
Set one or more attributes for the set of matched elements.
| Name | Desc |
| ------- | ---------------------- |
| element | Elements to manipulate |
| name | Attribute name |
| val | Attribute value |
| Name | Desc |
| ---------- | -------------------------------------- |
| element | Elements to manipulate |
| attributes | Object of attribute-value pairs to set |
### remove
Remove an attribute from each element in the set of matched elements.
| Name | Desc |
| ------- | ---------------------- |
| element | Elements to manipulate |
| name | Attribute name |
```javascript
$attr('#test', 'attr1', 'test');
$attr('#test', 'attr1'); // -> test
$attr.remove('#test', 'attr1');
$attr('#test', {
attr1: 'test',
attr2: 'test'
});
```
## \$class
Element class manipulations.
Type Definition
### add
Add the specified class(es) to each element in the set of matched elements.
| Name | Desc |
| ------- | ---------------------- |
| element | Elements to manipulate |
| names | Classes to add |
### has
Determine whether any of the matched elements are assigned the given class.
| Name | Desc |
| ------- | ------------------------------------- |
| element | Elements to manipulate |
| name | Class name |
| return | True if elements has given class name |
### toggle
Add or remove one or more classes from each element in the set of matched elements, depending on either the class's presence or the value of the state argument.
| Name | Desc |
| ------- | ---------------------- |
| element | Elements to manipulate |
| name | Class name to toggle |
### remove
Remove a single class, multiple classes, or all classes from each element in the set of matched elements.
| Name | Desc |
| ------- | ---------------------- |
| element | Elements to manipulate |
| name | Class names to remove |
```javascript
$class.add('#test', 'class1');
$class.add('#test', ['class1', 'class2']);
$class.has('#test', 'class1'); // -> true
$class.remove('#test', 'class1');
$class.has('#test', 'class1'); // -> false
$class.toggle('#test', 'class1');
$class.has('#test', 'class1'); // -> true
```
## \$css
Element css manipulation.
Type Definition
function $css(element: $safeEls.El, name: string): string;
function $css(
element: $safeEls.El,
name: string,
val: string
): void;
function $css(
element: $safeEls.El,
properties: types.PlainObj<string | number>
): void;
Get the computed style properties for the first element in the set of matched elements.
| Name | Desc |
| ------- | -------------------------- |
| element | Elements to manipulate |
| name | Property name |
| return | Css value of first element |
Set one or more CSS properties for the set of matched elements.
| Name | Desc |
| ------- | ---------------------- |
| element | Elements to manipulate |
| name | Property name |
| val | Css value |
| Name | Desc |
| ---------- | -------------------------------- |
| element | Elements to manipulate |
| properties | Object of css-value pairs to set |
```javascript
$css('#test', {
color: '#fff',
background: 'black',
opacity: 0.5
});
$css('#test', 'display', 'block');
$css('#test', 'color'); // -> #fff
```
## \$data
Wrapper of \$attr, adds data- prefix to keys.
Type Definition
function $data(
element: $safeEls.El,
name: string,
value: string
): void;
function $data(
element: $safeEls.El,
attributes: types.PlainObj<string>
): void;
function $data(element: $safeEls.El, name: string): string;
```javascript
$data('#test', 'attr1', 'eustia');
```
## \$event
bind events to certain dom elements.
Type Definition
```javascript
function clickHandler() {
// Do something...
}
$event.on('#test', 'click', clickHandler);
$event.off('#test', 'click', clickHandler);
```
## \$insert
Insert html on different position.
Type Definition
### before
Insert content before elements.
### after
Insert content after elements.
### prepend
Insert content to the beginning of elements.
### append
Insert content to the end of elements.
| Name | Desc |
| ------- | ----------------------- |
| element | Elements to manipulate |
| content | Html strings or element |
```javascript
//
$insert.before('#test', '
zso
');
// ->
zso
$insert.after('#test', '
zso
');
// ->
zso
$insert.prepend('#test', '
zso
');
// ->
zso
$insert.append('#test', '
zso
');
// ->
zso
```
## \$offset
Get the position of the element in document.
Type Definition
| Name | Desc |
| ------- | ---------------------- |
| element | Elements to get offset |
| return | Element position |
```javascript
$offset('#test'); // -> {left: 0, top: 0, width: 0, height: 0}
```
## \$property
Element property html, text, val getter and setter.
Type Definition
### html
Get the HTML contents of the first element in the set of matched elements or
set the HTML contents of every matched element.
### text
Get the combined text contents of each element in the set of matched
elements, including their descendants, or set the text contents of the
matched elements.
### val
Get the current value of the first element in the set of matched elements or
set the value of every matched element.
```javascript
$property.html('#test', 'zso');
$property.html('#test'); // -> zso
```
## \$remove
Remove the set of matched elements from the DOM.
Type Definition
function $remove(element: $safeEls.El);
| Name | Desc |
| ------- | ------------------ |
| element | Elements to delete |
```javascript
$remove('#test');
```
## \$safeEls
Convert value into an array, if it's a string, do querySelector.
Type Definition
namespace $safeEls {
type El = Element | Element[] | NodeListOf<Element> | string;
}
function $safeEls(val: $safeEls.El): Element[];
| Name | Desc |
| ------ | ----------------- |
| val | Value to convert |
| return | Array of elements |
```javascript
$safeEls(document.querySelector('.test'));
$safeEls(document.querySelectorAll('.test'));
$safeEls('.test'); // -> Array of elements with test class
```
## \$show
Show elements.
Type Definition
function $show(element: $safeEls.El): void;
| Name | Desc |
| ------- | ---------------- |
| element | Elements to show |
```javascript
$show('#test');
```
## Benchmark
JavaScript Benchmark.
Type Definition
### constructor
| Name | Desc |
| --------- | ------------------------ |
| size=1024 | Number of buckets |
| k=3 | Number of Hash functions |
### add
Add an element to the filter.
| Name | Desc |
| ---- | ------------ |
| val | Value to add |
### test
Test if an element is in the filter.
| Name | Desc |
| ------ | ----------------------------------------- |
| val | Value to test |
| return | True if probably, false if definitely not |
```javascript
const bloom = new BloomFilter(256, 3);
bloom.add('Bruce Wayne');
bloom.add('Clark Kent');
bloom.test('Clark Kent'); // -> true
bloom.test('Bruce Wayne'); // -> true
bloom.test('Tony Stark'); // -> false
```
## Caseless
Modify object props without caring about letter case.
Type Definition
### constructor
| Name | Desc |
| ---- | ------------- |
| obj | Target object |
### getKey
Get key with preserved casing.
| Name | Desc |
| ------ | ------------ |
| key | Caseless key |
| return | Object key |
### set
Set value.
| Name | Desc |
| ---- | ------------ |
| key | Caseless key |
| val | Value to set |
### get
Get value.
| Name | Desc |
| ------ | ------------------ |
| key | Caseless key |
| return | Value of given key |
### remove
Remove value.
| Name | Desc |
| ---- | ------------ |
| key | Caseless key |
### has
Determine whether target object has given key.
| Name | Desc |
| ------ | --------------------- |
| key | Caseless key |
| return | True if has given key |
```javascript
const headers = { 'Content-Type': 'text/javascript' };
const c = new Caseless(headers);
c.set('content-type', 'text/css');
console.log(headers); // -> { 'Content-Type': 'text/css' }
c.getKey('content-type'); // -> 'Content-Type'
c.remove('content-type');
c.has('content-type'); // -> false
```
## Class
Create JavaScript class.
Type Definition
namespace Class {
class Base {
toString(): string;
}
class IConstructor extends Base {
constructor(...args: any[]);
static extend(methods: any, statics: any): IConstructor;
static inherits(Class: types.AnyFn): void;
static methods(methods: any): IConstructor;
static statics(statics: any): IConstructor;
[method: string]: any;
}
}
function Class(methods: any, statics?: any): Class.IConstructor;
| Name | Desc |
| -------- | --------------------------------- |
| methods | Public methods |
| [statics | Static methods |
| return | Function used to create instances |
```javascript
const People = Class({
initialize: function People(name, age) {
this.name = name;
this.age = age;
},
introduce: function() {
return 'I am ' + this.name + ', ' + this.age + ' years old.';
}
});
const Student = People.extend(
{
initialize: function Student(name, age, school) {
this.callSuper(People, 'initialize', arguments);
this.school = school;
},
introduce: function() {
return (
this.callSuper(People, 'introduce') +
'\n I study at ' +
this.school +
'.'
);
}
},
{
is: function(obj) {
return obj instanceof Student;
}
}
);
const a = new Student('allen', 17, 'Hogwarts');
a.introduce(); // -> 'I am allen, 17 years old. \n I study at Hogwarts.'
Student.is(a); // -> true
```
## Color
Color converter.
Type Definition
namespace Color {
interface IColor {
val: number[];
model: string;
}
}
class Color {
constructor(color: string | Color.IColor);
toRgb(): string;
toHex(): string;
toHsl(): string;
static parse(colorStr: string): Color.IColor;
}
### constructor
| Name | Desc |
| ----- | ---------------- |
| color | Color to convert |
### toRgb
Get color rgb string format.
### toHex
Get color hex string format.
### toHsl
Get color hsl string format.
### parse
[static] Parse color string into object containing value and model.
| Name | Desc |
| ------ | --------------------------------- |
| color | Color string |
| return | Object containing value and model |
```javascript
Color.parse('rgb(170, 287, 204, 0.5)'); // -> {val: [170, 187, 204, 0.5], model: 'rgb'}
const color = new Color('#abc');
color.toRgb(); // -> 'rgb(170, 187, 204)'
color.toHsl(); // -> 'hsl(210, 25%, 73%)'
```
## Delegator
Object delegation.
Type Definition
Most api is the same as Store module, except only buffer is accepted.
### save
Save data to disk.
```javascript
const store = new FileBlobStore('path/to/file');
store.set('name', Buffer.from('zso'));
process.on('exit', () => store.save());
```
## FileStore
File storage.
Type Definition
class FileStore extends Store {
constructor(path: string, data?: any);
}
### constructor
| Name | Desc |
| ---- | ------------------ |
| path | File path to store |
| data | Default data |
```javascript
const store = new FileStore('path/to/file');
store.set('name', 'zso');
```
## HashTable
Hash table implementation.
Type Definition
### size
List size.
### head.
First node.
### tail
Last node.
### push
Add an value to the end of the list.
| Name | Desc |
| ------ | ------------- |
| val | Value to push |
| return | Current size |
### pop
Get the last value of the list.
### unshift
Add an value to the head of the list.
### shift
Get the first value of the list.
### rmNode
Remove node.
### find
Find node.
| Name | Desc |
| ------ | --------------------------------- |
| fn | Function invoked per iteration |
| return | First value that passes predicate |
### forEach
Iterate over the list.
### toArr
Convert the list to a JavaScript array.
```javascript
const linkedList = new LinkedList();
linkedList.push(5);
linkedList.pop(); // -> 5
```
## LocalStore
LocalStorage wrapper.
Type Definition
class LocalStore extends Store {
constructor(name: string, data?: {});
}
Extend from Store.
### constructor
| Name | Desc |
| ---- | ---------------------- |
| name | LocalStorage item name |
| data | Default data |
```javascript
const store = new LocalStore('zso');
store.set('name', 'zso');
```
## Logger
Simple logger with level filter.
Type Definition
### constructor
| Name | Desc |
| ---- | ------------------ |
| max | Max items in cache |
### has
Check if has cache.
| Name | Desc |
| ------ | -------------------- |
| key | Cache key |
| return | True if value exists |
### remove
Remove cache.
| Name | Desc |
| ---- | --------- |
| key | Cache key |
### get
Get cache value.
| Name | Desc |
| ------ | ----------- |
| key | Cache key |
| return | Cache value |
### set
Set cache.
| Name | Desc |
| ---- | ----------- |
| key | Cache key |
| val | Cache value |
### clear
Clear cache.
```javascript
const cache = new Lru(50);
cache.set('test', 'zso');
cache.get('test'); // -> 'zso'
```
## MediaQuery
CSS media query listener.
Type Definition
class MediaQuery extends Emitter {
constructor(query: string);
isMatch(): boolean;
}
Extend from Emitter.
### constructor
| Name | Desc |
| ----- | ----------- |
| query | Media query |
### isMatch
Return true if given media query matches.
### Events
#### match
Triggered when a media query matches.
#### unmatch
Opposite of match.
```javascript
const mediaQuery = new MediaQuery('screen and (max-width:1000px)');
mediaQuery.isMatch(); // -> false
mediaQuery.on('match', () => {
// Do something...
});
```
## MutationObserver
Safe MutationObserver, does nothing if MutationObserver is not supported.
```javascript
const observer = new MutationObserver(function(mutations) {
// Do something.
});
observer.observe(document.documentElement);
observer.disconnect();
```
## PriorityQueue
Priority queue implementation.
Type Definition
### size
Queue size.
### constructor
| Name | Desc |
| ---- | ---------- |
| cmp | Comparator |
### clear
Clear the queue.
### enqueue
Add an item to the queue.
| Name | Desc |
| ------ | ------------ |
| item | Item to add |
| return | Current size |
### dequeue
Retrieve and remove the highest priority item of the queue.
### peek
Same as dequeue, but does not remove the item.
```javascript
const queue = new PriorityQueue(function(a, b) {
if (a.priority > b.priority) return 1;
if (a.priority === b.priority) return -1;
return 0;
});
queue.enqueue({
priority: 1000,
value: 'apple'
});
queue.enqueue({
priority: 500,
value: 'orange'
});
queue.dequeue(); // -> { priority: 1000, value: 'apple' }
```
## Promise
Lightweight Promise implementation.
[Promises spec](https://github.com/promises-aplus/promises-spec)
```javascript
function get(url) {
return new Promise(function(resolve, reject) {
const req = new XMLHttpRequest();
req.open('GET', url);
req.onload = function() {
req.status == 200
? resolve(req.response)
: reject(Error(req.statusText));
};
req.onerror = function() {
reject(Error('Network Error'));
};
req.send();
});
}
get('test.json').then(function(result) {
// Do something...
});
```
## PseudoMap
Like es6 Map, without iterators.
Type Definition
const PseudoMap: typeof Map;
It supports only string keys, and uses Map if exists.
```javascript
const map = new PseudoMap();
map.set('1', 1);
map.get('1'); // -> 1
```
## Queue
Queue data structure.
Type Definition
Inspired by the [hashlru algorithm](https://github.com/dominictarr/hashlru#algorithm).
The api is the same as Lru module.
```javascript
const cache = new QuickLru(50);
cache.set('test', 'zso');
cache.get('test'); // -> 'zso'
```
## Readiness
Readiness manager.
Type Definition
### constructor
| Name | Desc |
| ------------ | --------------------------- |
| reducer | Function returns next state |
| initialState | Initial state |
### subscribe
Add a change listener.
| Name | Desc |
| -------- | ------------------------------------ |
| listener | Callback to invoke on every dispatch |
| return | Function to unsubscribe |
### dispatch
Dispatch an action.
| Name | Desc |
| ------ | --------------------------- |
| action | Object representing changes |
| return | Same action object |
### getState
Get the current state.
```javascript
const store = new ReduceStore(function(state, action) {
switch (action.type) {
case 'INCREMENT':
return state + 1;
case 'DECREMENT':
return state - 1;
default:
return state;
}
}, 0);
store.subscribe(function() {
console.log(store.getState());
});
store.dispatch({ type: 'INCREMENT' }); // 1
store.dispatch({ type: 'INCREMENT' }); // 2
store.dispatch({ type: 'DECREMENT' }); // 1
```
## ResizeSensor
Detect if element's size has changed.
Type Definition
class ResizeSensor extends SingleEmitter {
constructor(el: HTMLElement);
destroy(): void;
}
### constructor
| Name | Desc |
| ------- | ----------------------- |
| element | Element to monitor size |
### destroy
Stop monitoring resize event.
```javascript
const target = document.getElementById('test');
const sensor = new ResizeSensor(target);
sensor.addListener(function() {
// Trigger if element's size changed.
});
```
## Select
Simple wrapper of querySelectorAll to make dom selection easier.
Type Definition
class Select {
constructor(selector: string | Element | Document);
find(selector: string): Select;
each(fn: types.AnyFn): Select;
}
### constructor
| Name | Desc |
| -------- | ------------------- |
| selector | Dom selector string |
### find
Get desdendants of current matched elements.
| Name | Desc |
| -------- | ------------------- |
| selector | Dom selector string |
### each
Iterate over matched elements.
| Name | Desc |
| ---- | ------------------------------------ |
| fn | Function to execute for each element |
```javascript
const $test = new Select('#test');
$test.find('.test').each(function(idx, element) {
// Manipulate dom nodes
});
```
## Semaphore
Limit simultaneous access to a resource.
Type Definition
### constructor
| Name | Desc |
| --------- | --------------- |
| counter=1 | Initial counter |
### wait
Wait to execute until counter is bigger than 0.
| Name | Desc |
| ---- | ------------------- |
| fn | Function to execute |
### signal
Wake up one waiter if any.
```javascript
const sem = new Semaphore(10);
require('http')
.createServer((req, res) => {
sem.wait(function() {
res.end('.');
setTimeout(() => sem.signal(), 500);
});
})
.listen(3000);
```
## SessionStore
SessionStorage wrapper.
Type Definition
class SessionStore extends Store {
constructor(name: string, data?: any);
}
Extend from Store.
### constructor
| Name | Desc |
| ---- | ------------------------ |
| name | SessionStorage item name |
| data | Default data |
```javascript
const store = new SessionStore('zso');
store.set('name', 'zso');
```
## SingleEmitter
Event emitter with single event type.
Type Definition
### size
Stack size.
### clear
Clear the stack.
### push
Add an item to the stack.
| Name | Desc |
| ------ | ------------ |
| item | Item to add |
| return | Current size |
### pop
Get the last item of the stack.
### peek
Get the last item without removing it.
### forEach
Iterate over the stack.
| Name | Desc |
| -------- | -------------------------- |
| iterator | Function invoked iteration |
| ctx | Function context |
### toArr
Convert the stack to a JavaScript array.
```javascript
const stack = new Stack();
stack.push(2); // -> 1
stack.push(3); // -> 2
stack.pop(); // -> 3
```
## State
Simple state machine.
Type Definition
class State extends Emitter {
constructor(initial: string, events: any);
is(state: string): boolean;
[event: string]: any;
}
Extend from Emitter.
### constructor
| Name | Desc |
| ------- | ---------------------- |
| initial | Initial state |
| events | Events to change state |
### is
Check current state.
| Name | Desc |
| ------ | ---------------------------------------- |
| state | State to check |
| return | True if current state equals given value |
```javascript
const state = new State('empty', {
load: { from: 'empty', to: 'pause' },
play: { from: 'pause', to: 'play' },
pause: { from: ['play', 'empty'], to: 'pause' },
unload: { from: ['play', 'pause'], to: 'empty' }
});
state.is('empty'); // -> true
state.load();
state.is('pause'); // -> true
state.on('play', function(src) {
console.log(src); // -> 'eustia'
});
state.on('error', function(err, event) {
// Error handler
});
state.play('eustia');
```
## Store
Memory storage.
Type Definition
### constructor
| Name | Desc |
| ------- | --------------- |
| options | Tracing options |
Available options:
| Name | Desc |
| ----------- | ------------ |
| pid | Process id |
| tid | Thread id |
| processName | Process name |
| threadName | Thread name |
### start
Start recording.
| Name | Desc |
| ---- | ------------------ |
| cat | Enabled categories |
### stop
Stop recording and get result events.
### begin
Record begin event.
| Name | Desc |
| ---- | ---------------- |
| cat | Event categories |
| name | Event name |
| args | Arguments |
### end
Record end event.
### asyncBegin
Record async begin event.
### asyncEnd
Record async end event.
### instant
Record instant event.
### id
Get an unique id.
```javascript
const fs = require('fs');
const tracing = new Tracing();
tracing.start();
tracing.begin('cat', 'name');
// Do something...
tracing.end();
fs.writeFileSync(
'path/to/trace',
JSON.stringify(tracing.stop()),
'utf8',
function() {}
);
```
## Trie
Trie data structure.
Type Definition
### add
Add a word to trie.
| Name | Desc |
| ---- | ----------- |
| word | Word to add |
### remove
Remove a word from trie.
### has
Check if word exists.
### words
Get all words with given Prefix.
| Name | Desc |
| ------ | ----------------------- |
| prefix | Word prefix |
| return | Words with given Prefix |
### clear
Clear all words from trie.
```javascript
const trie = new Trie();
trie.add('carpet');
trie.add('car');
trie.add('cat');
trie.add('cart');
trie.has('cat'); // -> true
trie.remove('carpet');
trie.has('carpet'); // -> false
trie.words('car'); // -> ['car', 'cart']
trie.clear();
```
## Tween
Tween engine for JavaScript animations.
Type Definition
### size
Pool size.
### set
Set a value to the pool. Weight is updated if value already exists.
| Name | Desc |
| ------ | ------------------- |
| val | Value to set |
| weight | Weight of the value |
### get
Get weight of given value.
| Name | Desc |
| ------ | ------------------- |
| val | Value to get |
| return | Weight of the value |
### remove
Remove given value.
| Name | Desc |
| ---- | --------------- |
| val | Value to remove |
### next
Get next value from pool.
### clear
Clear all values.
```javascript
const pool = new Wrr();
pool.set('A', 4);
pool.set('B', 8);
pool.set('C', 2);
pool.next();
pool.remove('A');
console.log(pool.size); // -> 2
```
## abbrev
Calculate the set of unique abbreviations for a given set of strings.
Type Definition
function abbrev(...names: string[]): types.PlainObj<string>;
| Name | Desc |
| ------ | ---------------- |
| names | List of names |
| return | Abbreviation map |
```javascript
abbrev('lina', 'luna');
// -> {li: 'lina', lin: 'lina', lina: 'lina', lu: 'luna', lun: 'luna', luna: 'luna'}
```
## after
Create a function that invokes once it's called n or more times.
Type Definition
function after<T extends types.AnyFn>(n: number, fn: T): T;
| Name | Desc |
| ------ | ------------------------------ |
| n | Number of calls before invoked |
| fn | Function to restrict |
| return | New restricted function |
```javascript
const fn = after(5, function() {
// -> Only invoke after fn is called 5 times.
});
```
## ajax
Perform an asynchronous HTTP request.
Type Definition
### encode
Turn a byte array into a base64 string.
| Name | Desc |
| ------ | ------------- |
| bytes | Byte array |
| return | Base64 string |
### decode
Turn a base64 string into a byte array.
| Name | Desc |
| ------ | ------------- |
| str | Base64 string |
| return | Byte array |
```javascript
base64.encode([168, 174, 155, 255]); // -> 'qK6b/w=='
base64.decode('qK6b/w=='); // -> [168, 174, 155, 255]
```
## before
Create a function that invokes less than n times.
Type Definition
function before<T extends types.AnyFn>(n: number, fn: T): T;
| Name | Desc |
| ------ | ------------------------------------------------ |
| n | Number of calls at which fn is no longer invoked |
| fn | Function to restrict |
| return | New restricted function |
Subsequent calls to the created function return the result of the last fn invocation.
```javascript
const fn = before(5, function() {});
fn(); // Allow function to be call 4 times at last.
```
## between
Determines whether a value belongs to a certain interval.
Type Definition
function between(
number: number,
start: number,
end: number
): boolean;
function binarySearch(
array: any[],
val: any,
cmp?: types.AnyFn
): number;
| Name | Desc |
| ------ | ------------- |
| array | Sorted array |
| val | Value to seek |
| cmp | Comparator |
| return | Value index |
```javascript
binarySearch([1, 2, 3], 2); // -> 1
binarySearch([1, 2], 3); // -> -1
binarySearch(
[
{
key: 1
},
{
key: 2
}
],
{ key: 1 },
(a, b) => {
if (a.key === b.key) return 0;
return a.key < b.key ? -1 : 1;
}
); // -> 0
```
## bind
Create a function bound to a given object.
Type Definition
function bind(
fn: types.AnyFn,
ctx: any,
...args: any[]
): types.AnyFn;
| Name | Desc |
| ------ | ------------------------ |
| fn | Function to bind |
| ctx | This binding of given fn |
| args | Optional arguments |
| return | New bound function |
```javascript
const fn = bind(
function(msg) {
console.log(this.name + ':' + msg);
},
{ name: 'eustia' },
'I am a utility library.'
);
fn(); // -> 'eustia: I am a utility library.'
```
## btoa
Use Buffer to emulate btoa when running in node.
Type Definition
| Name | Desc |
| ------- | ------------- |
| options | Cache options |
Available options:
| Name | Desc |
| ----------------- | ------------------------------------- |
| dir | Cache dir |
| requirePath=true | Whether require path should be cached |
| code=false | Whether js code should be cached |
| compileCache=true | Whether compile cache should be used |
```javascript
cacheRequire({
dir: 'path/to/cache/dir'
});
```
## callbackify
Convert a function that returns a Promise to a function following the error-first callback style.
Type Definition
function callbackify(fn: types.AnyFn): types.AnyFn;
| Name | Desc |
| ------ | ------------------------------------------------ |
| fn | Function that returns a Promise |
| return | Function following the error-fist callback style |
```javascript
function fn() {
return new Promise(function(resolve, reject) {
// ...
});
}
const cbFn = callbackify(fn);
cbFn(function(err, value) {
// ...
});
```
## camelCase
Convert string to "camelCase".
Type Definition
function camelCase(str: string): string;
| Name | Desc |
| ------ | ------------------ |
| str | String to convert |
| return | Camel cased string |
```javascript
camelCase('foo-bar'); // -> fooBar
camelCase('foo bar'); // -> fooBar
camelCase('foo_bar'); // -> fooBar
camelCase('foo.bar'); // -> fooBar
```
## capitalize
Convert the first character to upper case and the remaining to lower case.
Type Definition
function capitalize(str: string): string;
| Name | Desc |
| ------ | -------------------- |
| str | String to capitalize |
| return | Capitalized string |
```javascript
capitalize('rED'); // -> Red
```
## castPath
Cast value into a property path array.
Type Definition
function castPath(path: string | string[], obj?: any): string[];
| Name | Desc |
| ------ | ------------------- |
| path | Value to inspect |
| obj | Object to query |
| return | Property path array |
```javascript
castPath('a.b.c'); // -> ['a', 'b', 'c']
castPath(['a']); // -> ['a']
castPath('a[0].b'); // -> ['a', '0', 'b']
castPath('a.b.c', { 'a.b.c': true }); // -> ['a.b.c']
```
## centerAlign
Center align text in a string.
Type Definition
function centerAlign(
str: string | string[],
width?: number
): string;
| Name | Desc |
| ------ | ------------------------ |
| str | String to align |
| width | Total width of each line |
| return | Center aligned string |
```javascript
centerAlign('test', 8); // -> ' test'
centerAlign('test\nlines', 8); // -> ' test\n lines'
centerAlign(['test', 'lines'], 8); // -> ' test\n lines'
```
## cgroup
Read cgroup metrics inside container.
Type Definition
```javascript
cgroup.cpu.stat();
```
## char
Return string representing a character whose Unicode code point is the given integer.
Type Definition
function char(num: number): string;
| Name | Desc |
| ------ | -------------------------------------- |
| num | Integer to convert |
| return | String representing corresponding char |
```javascript
char(65); // -> 'A'
char(97); // -> 'a'
```
## chunk
Split array into groups the length of given size.
Type Definition
function chunk(arr: any[], size?: number): Array<any[]>;
| Name | Desc |
| ------ | -------------------- |
| arr | Array to process |
| size=1 | Length of each chunk |
| return | Chunks of given size |
```javascript
chunk([1, 2, 3, 4], 2); // -> [[1, 2], [3, 4]]
chunk([1, 2, 3, 4], 3); // -> [[1, 2, 3], [4]]
chunk([1, 2, 3, 4]); // -> [[1], [2], [3], [4]]
```
## clamp
Clamp number within the inclusive lower and upper bounds.
Type Definition
function clamp(n: number, lower: number, upper: number): number;
function clamp(n: number, upper: number): number;
| Name | Desc |
| ------ | --------------- |
| n | Number to clamp |
| lower | Lower bound |
| upper | Upper bound |
| return | Clamped number |
```javascript
clamp(-10, -5, 5); // -> -5
clamp(10, -5, 5); // -> 5
clamp(2, -5, 5); // -> 2
clamp(10, 5); // -> 5
clamp(2, 5); // -> 2
```
## className
Utility for conditionally joining class names.
Type Definition
function className(...names: any[]): string;
| Name | Desc |
| ------ | ------------------ |
| names | Class names |
| return | Joined class names |
```javascript
className('a', 'b', 'c'); // -> 'a b c'
className('a', false, 'b', 0, 1, 'c'); // -> 'a b 1 c'
className('a', ['b', 'c']); // -> 'a b c'
className('a', { b: false, c: true }); // -> 'a c'
className('a', ['b', 'c', { d: true, e: false }]); // -> 'a b c d';
```
## cliHelp
Output cli help.
Type Definition
| Name | Desc |
| ------ | --------- |
| data | Help data |
| return | Cli help |
```javascript
const test = {
name: 'test',
desc: 'Generate test files',
usage: [' [options]', 'lpad --browser'],
options: [
{
name: 'browser',
shorthand: 'b',
desc: 'True if test should run in a browser'
}
]
};
const data = {
name: 'zso',
usage: ' [options]',
commands: [test]
};
cliHelp(data);
cliHelp(test);
```
## clone
Create a shallow-copied clone of the provided plain object.
Type Definition
function clone<T>(val: T): T;
Any nested objects or arrays will be copied by reference, not duplicated.
| Name | Desc |
| ------ | -------------- |
| val | Value to clone |
| return | Cloned value |
```javascript
clone({ name: 'eustia' }); // -> {name: 'eustia'}
```
## cloneDeep
Recursively clone value.
Type Definition
function cloneDeep<T>(val: T): T;
| Name | Desc |
| ------ | ----------------- |
| val | Value to clone |
| return | Deep cloned Value |
```javascript
const obj = [{ a: 1 }, { a: 2 }];
const obj2 = cloneDeep(obj);
console.log(obj[0] === obj2[1]); // -> false
```
## cmpVersion
Compare version strings.
Type Definition
function cmpVersion(v1: string, v2: string): number;
| Name | Desc |
| ------ | ------------------ |
| v1 | Version to compare |
| v2 | Version to compare |
| return | Comparison result |
```javascript
cmpVersion('1.1.8', '1.0.4'); // -> 1
cmpVersion('1.0.2', '1.0.2'); // -> 0
cmpVersion('2.0', '2.0.0'); // -> 0
cmpVersion('3.0.1', '3.0.0.2'); // -> 1
cmpVersion('1.1.1', '1.2.3'); // -> -1
```
## combine
Create an array by using one array for keys and another for its values.
Type Definition
function combine(keys: string[], values: any[]): any;
| Name | Desc |
| ------ | ----------------- |
| keys | Keys to be used |
| values | Values to be used |
| return | Created object |
```javascript
combine(['a', 'b', 'c'], [1, 2, 3]); // -> {a: 1, b: 2, c: 3}
```
## compact
Return a copy of the array with all falsy values removed.
Type Definition
function compact(arr: any[]): any[];
The values false, null, 0, "", undefined, and NaN are falsey.
| Name | Desc |
| ------ | ---------------------------- |
| arr | Array to compact |
| return | New array of filtered values |
```javascript
compact([0, 1, false, 2, '', 3]); // -> [1, 2, 3]
```
## compose
Compose a list of functions.
Type Definition
function compose(...fn: types.AnyFn[]): types.AnyFn;
Each function consumes the return value of the function that follows.
| Name | Desc |
| ------ | -------------------- |
| ...fn | Functions to compose |
| return | Composed function |
```javascript
const welcome = compose(
function(name) {
return 'hi: ' + name;
},
function(name) {
return name.toUpperCase() + '!';
}
);
welcome('zso'); // -> 'hi: ZSO!'
```
## compressImg
Compress image using canvas.
Type Definition
| Name | Desc |
| ------- | ----------------- |
| file | Image file or url |
| options | Options |
| cb | Callback |
Available options:
| Name | Desc |
| ----------- | -------------------------------- |
| maxWidth | Max width |
| maxHeight | Max height |
| width | Output image width |
| height | Output image height |
| mimeType | Mime type |
| quality=0.8 | Image quality, range from 0 to 1 |
In order to keep image ratio, height will be ignored when width is set.
And maxWith, maxHeight will be ignored if width or height is set.
```javascript
const file = new Blob([]);
compressImg(
file,
{
maxWidth: 200
},
function(err, file) {
// ...
}
);
```
## concat
Concat multiple arrays into a single array.
Type Definition
function concat(...args: Array<any[]>): any[];
| Name | Desc |
| ------ | ------------------ |
| ...arr | Arrays to concat |
| return | Concatenated array |
```javascript
concat([1, 2], [3], [4, 5]); // -> [1, 2, 3, 4, 5]
```
## contain
Check if the value is present in the list.
Type Definition
function contain(arr: any[] | {} | string, val: any): boolean;
| Name | Desc |
| ------ | ------------------------------------ |
| target | Target object |
| val | Value to check |
| return | True if value is present in the list |
```javascript
contain([1, 2, 3], 1); // -> true
contain({ a: 1, b: 2 }, 1); // -> true
contain('abc', 'a'); // -> true
```
## container
Get container stats inside container.
Type Definition
```javascript
container.cpuNum();
```
## convertBase
Convert base of a number.
Type Definition
function convertBase(
num: number | string,
from: number,
to: number
): string;
| Name | Desc |
| ------ | ----------------- |
| num | Number to convert |
| from | Base from |
| to | Base to |
| return | Converted number |
```javascript
convertBase('10', 2, 10); // -> '2'
convertBase('ff', 16, 2); // -> '11111111'
```
## convertBin
Convert binary data type.
Type Definition
namespace convertBin {
function blobToArrBuffer(blob: any): Promise<ArrayBuffer>;
}
function convertBin(bin: any, type: string): any;
| Name | Desc |
| ------ | ---------------------- |
| bin | Binary data to convert |
| type | Binary type |
| return | Target binary |
### Supported binary type
base64, ArrayBuffer, Array, Uint8Array, Blob(browser), Buffer(node)
You can not convert Blob to other types directly since it's an asynchronous process.
### blobToArrBuffer
Convert Blob to ArrayBuffer.
| Name | Desc |
| ------ | ------------------- |
| blob | Blob to convert |
| return | ArrayBuffer promise |
```javascript
convertBin('qK6b/w==', 'Uint8Array'); // -> [168, 174, 155, 255]
convertBin.blobToArrBuffer(new Blob([])).then(arrBuffer => {
// Do something...
});
```
## cookie
Simple api for handling browser cookies.
Type Definition
### get
Get cookie value.
| Name | Desc |
| ------ | -------------------------- |
| key | Cookie key |
| return | Corresponding cookie value |
### set
Set cookie value.
| Name | Desc |
| ------- | -------------- |
| key | Cookie key |
| val | Cookie value |
| options | Cookie options |
| return | Module cookie |
### remove
Remove cookie value.
| Name | Desc |
| ------- | -------------- |
| key | Cookie key |
| options | Cookie options |
| return | Module cookie |
```javascript
cookie.set('a', '1', { path: '/' });
cookie.get('a'); // -> '1'
cookie.remove('a');
```
## copy
Copy text to clipboard using document.execCommand.
Type Definition
function copy(text: string, cb?: types.AnyFn): void;
| Name | Desc |
| ---- | ----------------- |
| text | Text to copy |
| cb | Optional callback |
```javascript
copy('text', function(err) {
// Handle errors.
});
```
## crc1
CRC1 implementation.
Type Definition
function crc1(
input: string | number[],
previous?: number
): number;
| Name | Desc |
| -------- | -------------------- |
| input | Data to calculate |
| previous | Previous CRC1 result |
| return | CRC1 result |
```javascript
crc1('1234567890').toString(16); // -> 'd'
```
## crc16
CRC16 implementation.
Type Definition
function crc16(
input: string | number[],
previous?: number
): number;
| Name | Desc |
| -------- | --------------------- |
| input | Data to calculate |
| previous | Previous CRC16 result |
| return | CRC16 result |
```javascript
crc16('1234567890').toString(16); // -> 'c57a'
```
## crc32
CRC32 implementation.
Type Definition
function crc32(
input: string | number[],
previous?: number
): number;
| Name | Desc |
| -------- | --------------------- |
| input | Data to calculate |
| previous | Previous CRC32 result |
| return | CRC16 result |
```javascript
crc32('1234567890').toString(16); // -> '261daee5'
```
## crc8
CRC8 implementation.
Type Definition
function crc8(
input: string | number[],
previous?: number
): number;
| Name | Desc |
| -------- | -------------------- |
| input | Data to calculate |
| previous | Previous CRC8 result |
| return | CRC8 result |
```javascript
crc8('1234567890').toString(16); // -> '52'
```
## create
Create new object using given object as prototype.
Type Definition
function create(proto?: object): any;
| Name | Desc |
| ------ | ----------------------- |
| proto | Prototype of new object |
| return | Created object |
```javascript
const obj = create({ a: 1 });
console.log(obj.a); // -> 1
```
## createAssigner
Used to create extend, extendOwn and defaults.
Type Definition
function createAssigner(
keysFn: types.AnyFn,
defaults: boolean
): types.AnyFn;
| Name | Desc |
| -------- | ---------------------------- |
| keysFn | Function to get object keys |
| defaults | No override when set to true |
| return | Result function, extend... |
## createUrl
CreateObjectURL wrapper.
Type Definition
| Name | Desc |
| ------------- | --------------------- |
| date=new Date | Date object to format |
| mask | Format mask |
| utc=false | UTC or not |
| gmt=false | GMT or not |
| return | Formatted duration |
| Mask | Desc |
| ---- | ----------------------------------------------------------------- |
| d | Day of the month as digits; no leading zero for single-digit days |
| dd | Day of the month as digits; leading zero for single-digit days |
| ddd | Day of the week as a three-letter abbreviation |
| dddd | Day of the week as its full name |
| m | Month as digits; no leading zero for single-digit months |
| mm | Month as digits; leading zero for single-digit months |
| mmm | Month as a three-letter abbreviation |
| mmmm | Month as its full name |
| yy | Year as last two digits; leading zero for years less than 10 |
| yyyy | Year represented by four digits |
| h | Hours; no leading zero for single-digit hours (12-hour clock) |
| hh | Hours; leading zero for single-digit hours (12-hour clock) |
| H | Hours; no leading zero for single-digit hours (24-hour clock) |
| HH | Hours; leading zero for single-digit hours (24-hour clock) |
| M | Minutes; no leading zero for single-digit minutes |
| MM | Minutes; leading zero for single-digit minutes |
| s | Seconds; no leading zero for single-digit seconds |
| ss | Seconds; leading zero for single-digit seconds |
| l L | Milliseconds. l gives 3 digits. L gives 2 digits |
| t | Lowercase, single-character time marker string: a or p |
| tt | Lowercase, two-character time marker string: am or pm |
| T | Uppercase, single-character time marker string: A or P |
| TT | Uppercase, two-character time marker string: AM or PM |
| Z | US timezone abbreviation, e.g. EST or MDT |
| o | GMT/UTC timezone offset, e.g. -0500 or +0230 |
| S | The date's ordinal suffix (st, nd, rd, or th) |
| UTC: | Must be the first four characters of the mask |
```javascript
dateFormat('isoDate'); // -> 2016-11-19
dateFormat('yyyy-mm-dd HH:MM:ss'); // -> 2016-11-19 19:00:04
dateFormat(new Date(), 'yyyy-mm-dd'); // -> 2016-11-19
```
## debounce
Return a new debounced version of the passed function.
Type Definition
function debounce<T extends types.AnyFn>(fn: T, wait: number): T;
| Name | Desc |
| ------ | ------------------------------- |
| fn | Function to debounce |
| wait | Number of milliseconds to delay |
| return | New debounced function |
```javascript
const calLayout = debounce(function() {}, 300);
// $(window).resize(calLayout);
```
## debug
A tiny JavaScript debugging utility.
Type Definition
function debug(name: string): any;
| Name | Desc |
| ------ | ------------------------------- |
| name | Namespace |
| return | Function to print decorated log |
```javascript
const d = debug('test');
d('doing lots of uninteresting work');
d.enabled = false;
```
## deburr
Convert Latin-1 Supplement and Latin Extended-A letters to basic Latin letters and remove combining diacritical marks.
Type Definition
function deburr(str: string): string;
| Name | Desc |
| ------ | ---------------- |
| str | String to deburr |
| return | Deburred string |
```javascript
deburr('déjà vu'); // -> 'deja vu'
```
## decodeUriComponent
Better decodeURIComponent that does not throw if input is invalid.
Type Definition
function decodeUriComponent(str: string): string;
| Name | Desc |
| ------ | ---------------- |
| str | String to decode |
| return | Decoded string |
```javascript
decodeUriComponent('%%25%'); // -> '%%%'
decodeUriComponent('%E0%A4%A'); // -> '\xE0\xA4%A'
```
## defaults
Fill in undefined properties in object with the first value present in the following list of defaults objects.
Type Definition
function defaults(obj: any, ...src: any[]): any;
| Name | Desc |
| ------ | ------------------ |
| obj | Destination object |
| ...src | Sources objects |
| return | Destination object |
```javascript
defaults({ name: 'RedHood' }, { name: 'Unknown', age: 24 }); // -> {name: 'RedHood', age: 24}
```
## define
Define a module, should be used along with use.
Type Definition
function define(
name: string,
requires: string[],
method: types.AnyFn
): void;
function define(name: string, method: types.AnyFn): void;
| Name | Desc |
| -------- | ------------ |
| name | Module name |
| requires | Dependencies |
| method | Module body |
The module won't be executed until it's used by use function.
```javascript
define('A', function() {
return 'A';
});
define('B', ['A'], function(A) {
return 'B' + A;
});
```
## defineProp
Shortcut for Object.defineProperty(defineProperties).
Type Definition
function defineProp<T>(
obj: T,
prop: string,
descriptor: PropertyDescriptor
): T;
function defineProp<T>(
obj: T,
descriptor: PropertyDescriptorMap
): T;
| Name | Desc |
| ---------- | ------------------- |
| obj | Object to define |
| prop | Property path |
| descriptor | Property descriptor |
| return | Object itself |
| Name | Desc |
| ------ | -------------------- |
| obj | Object to define |
| prop | Property descriptors |
| return | Object itself |
```javascript
const obj = { b: { c: 3 }, d: 4, e: 5 };
defineProp(obj, 'a', {
get: function() {
return this.e * 2;
}
});
// obj.a is equal to 10
defineProp(obj, 'b.c', {
set: function(val) {
// this is pointed to obj.b
this.e = val;
}.bind(obj)
});
obj.b.c = 2;
// obj.a is equal to 4
const obj2 = { a: 1, b: 2, c: 3 };
defineProp(obj2, {
a: {
get: function() {
return this.c;
}
},
b: {
set: function(val) {
this.c = val / 2;
}
}
});
// obj2.a is equal to 3
obj2.b = 4;
// obj2.a is equal to 2
```
## defined
Return the first argument that is not undefined.
Type Definition
function defined(...args: any[]): any;
| Name | Desc |
| ------- | ---------------------- |
| ...args | Arguments to check |
| return | First defined argument |
```javascript
defined(false, 2, void 0, 100); // -> false
```
## delRequireCache
Delete node.js require cache.
Type Definition
function delRequireCache(id: string): void;
| Name | Desc |
| ---- | ------------------- |
| id | Module name or path |
```javascript
const zso = require('zso');
zso.a = 5;
delRequireCache('zso');
require('zso').a; // -> undefined
```
## delay
Invoke function after certain milliseconds.
Type Definition
function delay(
fn: types.AnyFn,
wait: number,
...args: any[]
): void;
| Name | Desc |
| ------- | ------------------------------------------ |
| fn | Function to delay |
| wait | Number of milliseconds to delay invocation |
| ...args | Arguments to invoke fn with |
```javascript
delay(
function(text) {
console.log(text);
},
1000,
'later'
);
// -> Logs 'later' after one second
```
## delegate
Event delegation.
Type Definition
| Name | Desc |
| ---------------------- | ---------------------------------- |
| ua=navigator.userAgent | Browser userAgent |
| return | Object containing name and version |
Browsers supported: ie, chrome, edge, firefox, opera, safari, ios(mobile safari), android(android browser)
```javascript
const browser = detectBrowser();
if (browser.name === 'ie' && browser.version < 9) {
// Do something about old IE...
}
```
## detectMocha
Detect if mocha is running.
Type Definition
function detectMocha(): boolean;
```javascript
detectMocha(); // -> True if mocha is running.
```
## detectOs
Detect operating system using ua.
Type Definition
function detectOs(ua?: string): string;
| Name | Desc |
| ---------------------- | --------------------- |
| ua=navigator.userAgent | Browser userAgent |
| return | Operating system name |
Supported os: windows, os x, linux, ios, android, windows phone
```javascript
if (detectOs() === 'ios') {
// Do something about ios...
}
```
## difference
Create an array of unique array values not included in the other given array.
Type Definition
function difference(arr: any[], ...args: any[]): any[];
| Name | Desc |
| ------- | ---------------------------- |
| arr | Array to inspect |
| ...args | Values to exclude |
| return | New array of filtered values |
```javascript
difference([3, 2, 1], [4, 2]); // -> [3, 1]
```
## dotCase
Convert string to "dotCase".
Type Definition
function dotCase(str: string): string;
| Name | Desc |
| ------ | ----------------- |
| str | String to convert |
| return | Dot cased string |
```javascript
dotCase('fooBar'); // -> foo.bar
dotCase('foo bar'); // -> foo.bar
```
## download
Trigger a file download on client side.
Type Definition
| Name | Desc |
| --------------- | ---------------- |
| data | Data to download |
| name | File name |
| type=text/plain | Data type |
```javascript
download('test', 'test.txt');
```
## durationFormat
Simple duration format function.
Type Definition
function durationFormat(duration: number, mask?: string): string;
| Name | Desc |
| --------------- | ------------------------------- |
| duration | Duration to format, millisecond |
| mask='hh:mm:ss' | Format mask |
| return | Formatted duration |
| Mask | Desc |
| ---- | ------------ |
| d | Days |
| h | Hours |
| m | Minutes |
| s | Seconds |
| l | Milliseconds |
```javascript
durationFormat(12345678); // -> '03:25:45'
durationFormat(12345678, 'h:m:s:l'); // -> '3:25:45:678'
```
## each
Iterate over elements of collection and invokes iterator for each element.
Type Definition
function each<T>(
list: types.List<T>,
iterator: types.ListIterator<T, void>,
ctx?: any
): types.List<T>;
function each<T>(
object: types.Dictionary<T>,
iterator: types.ObjectIterator<T, void>,
ctx?: any
): types.Collection<T>;
| Name | Desc |
| -------- | ------------------------------ |
| obj | Collection to iterate over |
| iterator | Function invoked per iteration |
| ctx | Function context |
```javascript
each({ a: 1, b: 2 }, function(val, key) {});
```
## easing
Easing functions adapted from http://jqueryui.com/ .
Type Definition
| Name | Desc |
| ------- | ---------------------- |
| percent | Number between 0 and 1 |
| return | Calculated number |
```javascript
easing.linear(0.5); // -> 0.5
easing.inElastic(0.5, 500); // -> 0.03125
```
## emulateTouch
Emulate touch events on desktop browsers.
Type Definition
function emulateTouch(el: Element): void;
| Name | Desc |
| ---- | -------------- |
| el | Target element |
```javascript
const el = document.querySelector('#test');
emulateTouch(el);
el.addEventListener('touchstart', () => {}, false);
```
## endWith
Check if string ends with the given target string.
Type Definition
function endWith(str: string, suffix: string): boolean;
| Name | Desc |
| ------ | ------------------------------- |
| str | The string to search |
| suffix | String suffix |
| return | True if string ends with target |
```javascript
endWith('ab', 'b'); // -> true
```
## escape
Escapes a string for insertion into HTML, replacing &, <, >, ", `, and ' characters.
Type Definition
function escape(str: string): string;
| Name | Desc |
| ------ | ---------------- |
| str | String to escape |
| return | Escaped string |
```javascript
escape('You & Me'); // -> 'You & Me'
```
## escapeJsStr
Escape string to be a valid JavaScript string literal between quotes.
Type Definition
function escapeJsStr(str: string): string;
http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
| Name | Desc |
| ------ | ---------------- |
| str | String to escape |
| return | Escaped string |
```javascript
escapeJsStr('"\n'); // -> '\\"\\\\n'
```
## escapeRegExp
Escape special chars to be used as literals in RegExp constructors.
Type Definition
function escapeRegExp(str: string): string;
| Name | Desc |
| ------ | ---------------- |
| str | String to escape |
| return | Escaped string |
```javascript
escapeRegExp('[zso]'); // -> '\\[zso\\]'
```
## evalCss
Load css into page.
Type Definition
function evalCss(css: string): HTMLStyleElement;
| Name | Desc |
| ------ | ------------- |
| css | Css code |
| return | Style element |
```javascript
evalCss('body{background:#08c}');
```
## evalJs
Execute js in given context.
Type Definition
function evalJs(js: string, ctx?: any): void;
| Name | Desc |
| ---------- | --------------- |
| js | JavaScript code |
| ctx=global | Context |
```javascript
evalJs('5+2'); // -> 7
evalJs('this.a', { a: 2 }); // -> 2
```
## every
Check if predicate return truthy for all elements.
Type Definition
function every<T>(
object: types.List<T>,
iterator?: types.ListIterator<T, boolean>,
context?: any
): boolean;
function every<T>(
object: types.Dictionary<T>,
iterator?: types.ObjectIterator<T, boolean>,
context?: any
): boolean;
| Name | Desc |
| -------- | --------------------------------------------- |
| object | Collection to iterate over |
| iterator | Function invoked per iteration |
| context | Predicate context |
| return | True if all elements pass the predicate check |
```javascript
every([2, 4], function(val) {
return val % 2 === 0;
}); // -> true
```
## extend
Copy all of the properties in the source objects over to the destination object.
Type Definition
function extend(destination: any, ...sources: any[]): any;
| Name | Desc |
| ------ | --------- |
| path | File path |
| return | File URL |
```javascript
fileUrl('c:\\foo\\bar'); // -> 'file:///c:/foo/bar'
```
## fill
Fill elements of array with value.
Type Definition
function fill(
list: any[],
val: any,
start?: number,
end?: number
): any[];
| Name | Desc |
| -------------- | ------------------------ |
| list | Array to fill |
| val | Value to fill array with |
| start=0 | Start position |
| end=arr.length | End position |
| return | Filled array |
```javascript
fill([1, 2, 3], '*'); // -> ['*', '*', '*']
fill([1, 2, 3], '*', 1, 2); // -> [1, '*', 3]
```
## filter
Iterates over elements of collection, returning an array of all the values that pass a truth test.
Type Definition
function filter<T>(
list: types.List<T>,
iterator: types.ListIterator<T, boolean>,
context?: any
): T[];
function filter<T>(
object: types.Dictionary<T>,
iterator: types.ObjectIterator<T, boolean>,
context?: any
): T[];
| Name | Desc |
| --------- | --------------------------------------- |
| obj | Collection to iterate over |
| predicate | Function invoked per iteration |
| ctx | Predicate context |
| return | Array of all values that pass predicate |
```javascript
filter([1, 2, 3, 4, 5], function(val) {
return val % 2 === 0;
}); // -> [2, 4]
```
## find
Find the first value that passes a truth test in a collection.
Type Definition
function find<T>(
object: types.List<T>,
iterator: types.ListIterator<T, boolean>,
context?: any
): T | undefined;
function find<T>(
object: types.Dictionary<T>,
iterator: types.ObjectIterator<T, boolean>,
context?: any
): T | undefined;
| Name | Desc |
| -------- | --------------------------------- |
| object | Collection to iterate over |
| iterator | Function invoked per iteration |
| context | Predicate context |
| return | First value that passes predicate |
```javascript
find(
[
{
name: 'john',
age: 24
},
{
name: 'jane',
age: 23
}
],
function(val) {
return val.age === 23;
}
); // -> {name: 'jane', age: 23}
```
## findIdx
Return the first index where the predicate truth test passes.
Type Definition
function findIdx(arr: any[], predicate: types.AnyFn): number;
| Name | Desc |
| --------- | ------------------------------ |
| arr | Array to search |
| predicate | Function invoked per iteration |
| return | Index of matched element |
```javascript
findIdx(
[
{
name: 'john',
age: 24
},
{
name: 'jane',
age: 23
}
],
function(val) {
return val.age === 23;
}
); // -> 1
```
## findKey
Return the first key where the predicate truth test passes.
Type Definition
function findKey(
obj: any,
predicate: types.AnyFn,
ctx?: any
): string | void;
| Name | Desc |
| --------- | ------------------------------ |
| obj | Object to search |
| predicate | Function invoked per iteration |
| ctx | Predicate context |
| return | Key of matched element |
```javascript
findKey({ a: 1, b: 2 }, function(val) {
return val === 1;
}); // -> a
```
## findLastIdx
Return the last index where the predicate truth test passes.
Type Definition
function findLastIdx(arr: any[], predicate: types.AnyFn): number;
| Name | Desc |
| --------- | ------------------------------ |
| arr | Array to search |
| predicate | Function invoked per iteration |
| return | Last index of matched element |
```javascript
findLastIdx(
[
{
name: 'john',
age: 24
},
{
name: 'jane',
age: 23
},
{
name: 'kitty',
age: 24
}
],
function(val) {
return val.age === 24;
}
); // -> 2
```
## flatten
Recursively flatten an array.
Type Definition
function flatten(arr: any[]): any[];
| Name | Desc |
| ------ | ------------------- |
| arr | Array to flatten |
| return | New flattened array |
```javascript
flatten(['a', ['b', ['c']], 'd', ['e']]); // -> ['a', 'b', 'c', 'd', 'e']
```
## fnArgs
Validate function arguments.
Type Definition
function fnArgs(types: string[], args: any): void;
| Name | Desc |
| ----- | --------------- |
| types | Argument types |
| args | Argument object |
It throws an exception when validation failed.
```javascript
function test(a, b, c) {
fnArgs(['number|string', '?Function', '...number'], arguments);
// Do something.
}
test(15);
test('test', () => {});
test('test', () => {}, 5);
test(); // Throw error
test('test', 'test'); // Throw error
test('test', () => {}, 5, 'test'); // Throw error
```
## fnParams
Get a function parameter's names.
Type Definition
function fnParams(fn: types.AnyFn | string): string[];
| Name | Desc |
| ------ | -------------------------- |
| fn | Function to get parameters |
| return | Names |
```javascript
fnParams(function(a, b) {}); // -> ['a', 'b']
```
## fnv1a
Simple FNV-1a implementation.
Type Definition
function fnv1a(str: string): number;
| Name | Desc |
| ------ | -------------- |
| str | String to hash |
| return | Hast result |
```javascript
fnv1a('test'); // -> 2949673445
```
## format
Format string in a printf-like format.
Type Definition
function format(str: string, ...values: any[]): string;
| Name | Desc |
| --------- | ----------------------------------- |
| str | String to format |
| ...values | Values to replace format specifiers |
| return | Formatted string |
### Format Specifiers
| Specifier | Desc |
| --------- | -------------------- |
| %s | String |
| %d, %i | Integer |
| %f | Floating point value |
| %o | Object |
```javascript
format('%s_%s', 'foo', 'bar'); // -> 'foo_bar'
```
## fraction
Convert number to fraction.
Type Definition
function fraction(num: number): string;
| Name | Desc |
| ------ | ---------------------- |
| num | Number to convert |
| return | Corresponding fraction |
```javascript
fraction(1.2); // -> '6/5'
```
## freeze
Shortcut for Object.freeze.
Type Definition
function freeze<T>(obj: T): T;
Use Object.defineProperties if Object.freeze is not supported.
| Name | Desc |
| ------ | ---------------- |
| obj | Object to freeze |
| return | Object passed in |
```javascript
const a = { b: 1 };
freeze(a);
a.b = 2;
console.log(a); // -> {b: 1}
```
## freezeDeep
Recursively use Object.freeze.
Type Definition
function freezeDeep<T>(obj: T): T;
| Name | Desc |
| ------ | ---------------- |
| obj | Object to freeze |
| return | Object passed in |
```javascript
const a = { b: { c: 1 } };
freezeDeep(a);
a.b.c = 2;
console.log(a); // -> {b: {c: 1}}
```
## fs
Promised version of node.js fs module.
Type Definition
| Name | Desc |
| --------- | ---------------- |
| needle | String to search |
| haystacks | Search list |
| options | Search options |
Available options:
| Name | Desc |
| ------------------- | -------------------------------------------- |
| caseSensitive=false | Whether comparisons should be case sensitive |
| key | Object key path if item is object |
```javascript
fuzzySearch('lic', ['zso', 'll', 'lic']); // -> ['lic', 'zso']
fuzzySearch(
'alpha-test',
[
{
name: 'alpha-test-1'
},
{
name: 'beta-test'
}
],
{
key: 'name'
}
); // -> [{ name: 'alpha-test-1' }]
```
## gcd
Compute the greatest common divisor using Euclid's algorithm.
Type Definition
function gcd(a: number, b: number): number;
| Name | Desc |
| ------ | ----------------------- |
| a | Number to calculate |
| b | Number to calculate |
| return | Greatest common divisor |
```javascript
gcd(121, 44); // -> 11
```
## getPort
Get an available TCP port.
Type Definition
function getPort(
port?: number | number[],
host?: string
): Promise<number>;
| Name | Desc |
| ------ | --------------- |
| port | Preferred ports |
| host | Host address |
| return | Available port |
If preferred ports are not available, a random port will be returned.
```javascript
getPort([3000, 3001], '127.0.0.1').then(port => {
console.log(port);
});
```
## getProto
Get prototype of an object.
Type Definition
function getProto(obj: any): any;
| Name | Desc |
| ------ | --------------------------------------------- |
| obj | Target object |
| return | Prototype of given object, null if not exists |
```javascript
const a = {};
getProto(Object.create(a)); // -> a
```
## getUrlParam
Get url param.
Type Definition
function getUrlParam(
name: string,
url?: string
): string | undefined;
| Name | Desc |
| ------------ | ---------------- |
| name | Param name |
| url=location | Url to get param |
| return | Param value |
```javascript
getUrlParam('test', 'http://example.com/?test=true'); // -> 'true'
```
## golangify
Handle errors like golang.
Type Definition
function golangify<T, U = Error>(
fn: (...args: any[]) => Promise<T>
): (...args: any[]) => Promise<[T | undefined, U | null]>;
function golangify<T, U = Error>(
p: Promise<T>
): Promise<[T | undefined, U | null]>;
| Name | Desc |
| ------ | ------------------------------------------ |
| fn | Function that returns a Promise |
| return | Like fn, but resolves with [result, error] |
| Name | Desc |
| ------ | ------------------------------------------ |
| p | Promise to transform |
| return | Promise that resolves with [result, error] |
```javascript
(async () => {
let fnA = golangify(async () => {
throw Error('err');
});
await fnA(); // -> [undefined, Error]
let fnB = golangify(async num => num * 2);
await fnB(2); // -> [4, null]
await golangify(Promise.reject(Error('err'))); // -> [undefined, Error]
await golangify(Promise.resolve(4)); // -> [4, null]
})();
```
## h
Create html with JavaScript.
Type Definition
| Name | Desc |
| -------- | --------------- |
| tag | Tag name |
| attrs | Attributes |
| ...child | Children |
| return | Created element |
```javascript
const el = h(
'div#test.title',
{
onclick: function() {},
title: 'test'
},
'inner text'
);
document.body.appendChild(el);
```
## has
Checks if key is a direct property.
Type Definition
function has(obj: {}, key: string): boolean;
| Name | Desc |
| ------ | -------------------------------- |
| obj | Object to query |
| key | Path to check |
| return | True if key is a direct property |
```javascript
has({ one: 1 }, 'one'); // -> true
```
## heapSort
Heap sort implementation.
Type Definition
function heapSort(arr: any[], cmp?: types.AnyFn): any[];
### parse
Parse html string into js object.
| Name | Desc |
| ------ | ---------------- |
| html | Html string |
| return | Parsed js object |
### stringify
Stringify object into an html string.
| Name | Desc |
| ------ | ------------------- |
| tree | Object to stringify |
| return | Html string |
```javascript
const tree = html.parse('
zso
');
// -> [{tag: 'div', attrs: {id: 'name'}, content: ['zso']}]
html.stringify(tree);
```
## identity
Return the first argument given.
Type Definition
function identity<T>(val: T): T;
| Name | Desc |
| ------ | ----------- |
| val | Any value |
| return | Given value |
```javascript
identity('a'); // -> 'a'
```
## idxOf
Get the index at which the first occurrence of value.
Type Definition
function idxOf(arr: any[], val: any, fromIdx?: number): number;
| Name | Desc |
| --------- | -------------------- |
| arr | Array to search |
| val | Value to search for |
| fromIdx=0 | Index to search from |
| return | Value index |
```javascript
idxOf([1, 2, 1, 2], 2, 2); // -> 3
```
## indent
Indent each line in a string.
Type Definition
function indent(
str: string,
char?: string,
len?: number
): string;
| Name | Desc |
| ------ | -------------------- |
| str | String to indent |
| char | Character to prepend |
| len | Indent length |
| return | Indented string |
```javascript
indent('foo\nbar', ' ', 4); // -> ' foo\n bar'
```
## inherits
Inherit the prototype methods from one constructor into another.
Type Definition
function inherits(
Class: types.AnyFn,
SuperClass: types.AnyFn
): void;
| Name | Desc |
| ---------- | ----------- |
| Class | Child Class |
| SuperClass | Super Class |
```javascript
function People(name) {
this._name = name;
}
People.prototype = {
getName: function() {
return this._name;
}
};
function Student(name) {
this._name = name;
}
inherits(Student, People);
const s = new Student('RedHood');
s.getName(); // -> 'RedHood'
```
## ini
Ini parser and serializer.
Type Definition
### parse
Parse ini string into js object.
| Name | Desc |
| ------ | ---------------- |
| ini | Ini string |
| return | Parsed js object |
### stringify
Stringify object into an ini formatted string.
| Name | Desc |
| ------- | -------------------- |
| obj | Object to stringify |
| options | Stringify options |
| return | Ini formatted string |
Options:
| Name | Desc |
| ---------------- | ------------------- |
| section | Top section |
| whitespace=false | Whitespace around = |
```javascript
const config = ini.parse(`
; This is a comment
library = zso
[user.info]
name = surunzi
alias[] = ooo9
alias[] = red
`); // -> {library: 'zso', user: {info: {name: 'surunzi', alias: ['ooo9', 'red']}}}
ini.stringify(config);
```
## insertionSort
Insertion sort implementation.
Type Definition
function insertionSort(arr: any[], cmp?: types.AnyFn): any[];
| Name | Desc |
| ------ | ------------- |
| arr | Array to sort |
| cmp | Comparator |
| return | Sorted array |
```javascript
insertionSort([2, 1]); // -> [1, 2]
```
## intersect
Compute the list of values that are the intersection of all the arrays.
Type Definition
function intersect(...arr: Array<any[]>): any[];
| Name | Desc |
| ------ | ------------------------------ |
| ...arr | Arrays to inspect |
| return | New array of inspecting values |
```javascript
intersect([1, 2, 3, 4], [2, 1, 10], [2, 1]); // -> [1, 2]
```
## intersectRange
Intersect two ranges.
Type Definition
[Related docs](https://github.com/zertosh/invariant)
```javascript
invariant(true, 'This will not throw');
// No errors
invariant(false, 'This will throw an error with this message');
// Error: Invariant Violation: This will throw an error with this message
```
## invert
Create an object composed of the inverted keys and values of object.
Type Definition
function invert(obj: any): any;
| Name | Desc |
| ------ | ------------------- |
| obj | Object to invert |
| return | New inverted object |
If object contains duplicate values, subsequent values overwrite property assignments of previous values.
```javascript
invert({ a: 'b', c: 'd', e: 'f' }); // -> {b: 'a', d: 'c', f: 'e'}
```
## isAbsoluteUrl
Check if an url is absolute.
Type Definition
function isAbsoluteUrl(url: string): boolean;
| Name | Desc |
| ------ | ----------------------- |
| url | Url to check |
| return | True if url is absolute |
```javascript
isAbsoluteUrl('http://www.surunzi.com'); // -> true
isAbsoluteUrl('//www.surunzi.com'); // -> false
isAbsoluteUrl('surunzi.com'); // -> false
```
## isArgs
Check if value is classified as an arguments object.
Type Definition
function isArgs(val: any): boolean;
| Name | Desc |
| ------ | ------------------------------------ |
| val | Value to check |
| return | True if value is an arguments object |
```javascript
isArgs(
(function() {
return arguments;
})()
); // -> true
```
## isArr
Check if value is an `Array` object.
Type Definition
function isArr(val: any): boolean;
| Name | Desc |
| ------ | ---------------------------------- |
| val | Value to check |
| return | True if value is an `Array` object |
```javascript
isArr([]); // -> true
isArr({}); // -> false
```
## isArrBuffer
Check if value is an ArrayBuffer.
Type Definition
function isArrBuffer(val: any): boolean;
| Name | Desc |
| ------ | ------------------------------- |
| val | Value to check |
| return | True if value is an ArrayBuffer |
```javascript
isArrBuffer(new ArrayBuffer(8)); // -> true
```
## isArrLike
Check if value is array-like.
Type Definition
function isArrLike(val: any): boolean;
| Name | Desc |
| ------ | --------------------------- |
| val | Value to check |
| return | True if value is array like |
Function returns false.
```javascript
isArrLike('test'); // -> true
isArrLike(document.body.children); // -> true;
isArrLike([1, 2, 3]); // -> true
```
## isAsyncFn
Check if value is an async function.
Type Definition
function isAsyncFn(val: any): boolean;
| Name | Desc |
| ------ | ---------------------------------- |
| val | Value to check |
| return | True if value is an async function |
```javascript
isAsyncFn(function*() {}); // -> false
isAsyncFn(function() {}); // -> false
isAsyncFn(async function() {}); // -> true
```
## isBlob
Check if value is a Blob.
Type Definition
function isBlob(val: any): boolean;
| Name | Desc |
| ------ | ----------------------- |
| val | Value to check |
| return | True if value is a Blob |
```javascript
isBlob(new Blob([])); // -> true;
isBlob([]); // -> false
```
## isBool
Check if value is a boolean primitive.
Type Definition
function isBool(val: any): boolean;
| Name | Desc |
| ------ | -------------------------- |
| val | Value to check |
| return | True if value is a boolean |
```javascript
isBool(true); // -> true
isBool(false); // -> true
isBool(1); // -> false
```
## isBrowser
Check if running in a browser.
Type Definition
const isBrowser: boolean;
```javascript
console.log(isBrowser); // -> true if running in a browser
```
## isBuffer
Check if value is a buffer.
Type Definition
function isBuffer(val: any): boolean;
| Name | Desc |
| ------ | ------------------------- |
| val | The value to check |
| return | True if value is a buffer |
```javascript
isBuffer(new Buffer(4)); // -> true
```
## isClose
Check if values are close(almost equal) to each other.
Type Definition
function isClose(
a: number,
b: number,
relTol?: number,
absTol?: number
): boolean;
`abs(a-b) <= max(relTol * max(abs(a), abs(b)), absTol)`
| Name | Desc |
| ----------- | ------------------------ |
| a | Number to compare |
| b | Number to compare |
| relTol=1e-9 | Relative tolerance |
| absTol=0 | Absolute tolerance |
| return | True if values are close |
```javascript
isClose(1, 1.0000000001); // -> true
isClose(1, 2); // -> false
isClose(1, 1.2, 0.3); // -> true
isClose(1, 1.2, 0.1, 0.3); // -> true
```
## isCyclic
Detect cyclic object reference.
Type Definition
function isCyclic(val: any): boolean;
| Name | Desc |
| ------ | ----------------------- |
| val | Value to detect |
| return | True if value is cyclic |
```javascript
isCyclic({}); // -> false
const obj = { a: 1 };
obj.b = obj;
isCyclic(obj); // -> true
```
## isDarkMode
Detect dark mode.
Type Definition
function isDarkMode(): boolean;
```javascript
console.log(isDarkMode()); // true if dark mode
```
## isDataUrl
Check if a string is a valid data url.
Type Definition
function isDataUrl(str: string): boolean;
| Name | Desc |
| ------ | ---------------------------- |
| str | String to check |
| return | True if string is a data url |
```javascript
isDataUrl('http://eustia.ooo9.io'); // -> false
isDataUrl('data:text/plain;base64,SGVsbG8sIFdvcmxkIQ%3D%3D'); // -> true
```
## isDate
Check if value is classified as a Date object.
Type Definition
function isDate(val: any): boolean;
| Name | Desc |
| ------ | ------------------------------ |
| val | value to check |
| return | True if value is a Date object |
```javascript
isDate(new Date()); // -> true
```
## isDir
Check if a path is directory.
Type Definition
function isDir(path: string): Promise<boolean>;
| Name | Desc |
| ------ | --------------------------- |
| path | Path to check |
| return | True if path is a directory |
```javascript
isDir('/foo/bar');
```
## isDocker
Check if the process is running inside a docker container.
Type Definition
function isDocker(): boolean;
```javascript
console.log(isDocker()); // -> true if running inside a docker container.
```
## isEl
Check if value is a DOM element.
Type Definition
function isEl(val: any): boolean;
| Name | Desc |
| ------ | ------------------------------ |
| val | Value to check |
| return | True if value is a DOM element |
```javascript
isEl(document.body); // -> true
```
## isEmail
Loosely validate an email address.
Type Definition
function isEmail(val: string): boolean;
| Name | Desc |
| ------ | ------------------------------------- |
| val | Value to check |
| return | True if value is an email like string |
```javascript
isEmail('surunzi@foxmail.com'); // -> true
```
## isEmpty
Check if value is an empty object or array.
Type Definition
function isEmpty(val: any): boolean;
| Name | Desc |
| ------ | ---------------------- |
| val | Value to check |
| return | True if value is empty |
```javascript
isEmpty([]); // -> true
isEmpty({}); // -> true
isEmpty(''); // -> true
```
## isEqual
Performs an optimized deep comparison between the two objects, to determine if they should be considered equal.
Type Definition
function isEqual(val: any, other: any): boolean;
| Name | Desc |
| ------ | ----------------------------- |
| val | Value to compare |
| other | Other value to compare |
| return | True if values are equivalent |
```javascript
isEqual([1, 2, 3], [1, 2, 3]); // -> true
```
## isErr
Check if value is an error.
Type Definition
function isErr(val: any): boolean;
| Name | Desc |
| ------ | ------------------------- |
| val | Value to check |
| return | True if value is an error |
```javascript
isErr(new Error()); // -> true
```
## isEven
Check if number is even.
Type Definition
function isEven(num: number): boolean;
| Name | Desc |
| ------ | ---------------------- |
| num | Number to check |
| return | True if number is even |
```javascript
isEven(0); // -> true
isEven(1); // -> false
isEven(2); // -> true
```
## isFile
Check if value is a file.
Type Definition
function isFile(val: any): boolean;
| Name | Desc |
| ------ | ----------------------- |
| val | Value to check |
| return | True if value is a file |
```javascript
isFile(new File(['test'], 'test.txt', { type: 'text/plain' })); // -> true
```
## isFinite
Check if value is a finite primitive number.
Type Definition
function isFinite(val: any): boolean;
| Name | Desc |
| ------ | -------------------------------- |
| val | Value to check |
| return | True if value is a finite number |
```javascript
isFinite(3); // -> true
isFinite(Infinity); // -> false
```
## isFn
Check if value is a function.
Type Definition
function isFn(val: any): boolean;
| Name | Desc |
| ------ | --------------------------- |
| val | Value to check |
| return | True if value is a function |
Generator function is also classified as true.
```javascript
isFn(function() {}); // -> true
isFn(function*() {}); // -> true
isFn(async function() {}); // -> true
```
## isFullWidth
Check if character is full width.
Type Definition
function isFullWidth(codePoint: number): boolean;
| Name | Desc |
| --------- | ------------------------------- |
| codePoint | Unicode code point |
| return | True if character is full width |
```javascript
isFullWidth('a'.codePointAt(0)); // -> false
isFullWidth(','.codePointAt(0)); // -> false
isFullWidth('我'.codePointAt(0)); // -> true
isFullWidth('，'.codePointAt(0)); // -> true
```
## isGeneratorFn
Check if value is a generator function.
Type Definition
function isGeneratorFn(val: any): boolean;
| Name | Desc |
| ------ | ------------------------------------- |
| val | Value to check |
| return | True if value is a generator function |
```javascript
isGeneratorFn(function*() {}); // -> true
isGeneratorFn(function() {}); // -> false
```
## isHidden
Check if element is hidden.
Type Definition
| Name | Desc |
| ------- | ------------------------- |
| el | Target element |
| options | Check options |
| return | True if element is hidden |
Available options:
| Name | Desc |
| ---------------- | ----------------------------- |
| display=true | Check if it is displayed |
| visibility=false | Check visibility css property |
| opacity=false | Check opacity css property |
| size=false | Check width and height |
| viewport=false | Check if it is in viewport |
| overflow=false | Check if hidden in overflow |
```javascript
isHidden(document.createElement('div')); // -> true
```
## isInt
Checks if value is classified as a Integer.
Type Definition
function isInt(val: any): boolean;
| Name | Desc |
| ------ | ------------------------------------- |
| val | Value to check |
| return | True if value is correctly classified |
```javascript
isInt(5); // -> true
isInt(5.1); // -> false
isInt({}); // -> false
```
## isIp
Check if value is an IP address.
Type Definition
namespace isIp {
function v4(str: string): boolean;
function v6(str: string): boolean;
}
function isIp(str: string): boolean;
| Name | Desc |
| ------ | ------------------------------ |
| str | String to check |
| return | True if value is an IP address |
### v4
Check if value is an IPv4 address.
### v6
Check if value is an IPv6 address.
```javascript
isIp('192.168.191.1'); // -> true
isIp('1:2:3:4:5:6:7:8'); // -> true
isIp('test'); // -> false
isIp.v4('192.168.191.1'); // -> true
isIp.v6('1:2:3:4:5:6:7:8'); // -> true
```
## isJson
Check if value is a valid JSON.
Type Definition
function isJson(val: string): boolean;
It uses `JSON.parse()` and a `try... catch` block.
| Name | Desc |
| ------ | ----------------------------- |
| val | JSON string |
| return | True if value is a valid JSON |
```javascript
isJson('{"a": 5}'); // -> true
isJson("{'a': 5}"); // -> false
```
## isLeapYear
Check if a year is a leap year.
Type Definition
function isLeapYear(year: number): boolean;
| Name | Desc |
| ------ | --------------------------- |
| year | Year to check |
| return | True if year is a leap year |
```javascript
isLeapYear(2000); // -> true
isLeapYear(2002); // -> false
```
## isMap
Check if value is a Map object.
Type Definition
function isMap(val: any): boolean;
| Name | Desc |
| ------ | ---------------------- |
| val | Value to check |
| return | True if value is a Map |
```javascript
isMap(new Map()); // -> true
isMap(new WeakMap()); // -> false
```
## isMatch
Check if keys and values in src are contained in obj.
Type Definition
function isMatch(obj: any, src: any): boolean;
| Name | Desc |
| ------ | ---------------------------------- |
| obj | Object to inspect |
| src | Object of property values to match |
| return | True if object is match |
```javascript
isMatch({ a: 1, b: 2 }, { a: 1 }); // -> true
```
## isMiniProgram
Check if running in wechat mini program.
Type Definition
const isMiniProgram: boolean;
```javascript
console.log(isMiniProgram); // -> true if running in mini program.
```
## isMobile
Check whether client is using a mobile browser using ua.
Type Definition
function isMobile(ua?: string): boolean;
| Name | Desc |
| ---------------------- | ------------------------------------- |
| ua=navigator.userAgent | User agent |
| return | True if ua belongs to mobile browsers |
```javascript
isMobile(navigator.userAgent);
```
## isNaN
Check if value is an NaN.
Type Definition
function isNaN(val: any): boolean;
| Name | Desc |
| ------ | ----------------------- |
| val | Value to check |
| return | True if value is an NaN |
Undefined is not an NaN, different from global isNaN function.
```javascript
isNaN(0); // -> false
isNaN(NaN); // -> true
```
## isNative
Check if value is a native function.
Type Definition
function isNative(val: any): boolean;
| Name | Desc |
| ------ | ---------------------------------- |
| val | Value to check |
| return | True if value is a native function |
```javascript
isNative(function() {}); // -> false
isNative(Math.min); // -> true
```
## isNil
Check if value is null or undefined, the same as value == null.
Type Definition
function isNil(val: any): boolean;
| Name | Desc |
| ------ | ---------------------------------- |
| val | Value to check |
| return | True if value is null or undefined |
```javascript
isNil(null); // -> true
isNil(void 0); // -> true
isNil(undefined); // -> true
isNil(false); // -> false
isNil(0); // -> false
isNil([]); // -> false
```
## isNode
Check if running in node.
Type Definition
const isNode: boolean;
```javascript
console.log(isNode); // -> true if running in node
```
## isNull
Check if value is an Null.
Type Definition
function isNull(val: any): boolean;
| Name | Desc |
| ------ | ------------------------ |
| val | Value to check |
| return | True if value is an Null |
```javascript
isNull(null); // -> true
```
## isNum
Check if value is classified as a Number primitive or object.
Type Definition
function isNum(val: any): boolean;
| Name | Desc |
| ------ | ------------------------------------- |
| val | Value to check |
| return | True if value is correctly classified |
```javascript
isNum(5); // -> true
isNum(5.1); // -> true
isNum({}); // -> false
```
## isNumeric
Check if value is numeric.
Type Definition
function isNumeric(val: any): boolean;
| Name | Desc |
| ------ | ------------------------ |
| val | Value to check |
| return | True if value is numeric |
```javascript
isNumeric(1); // -> true
isNumeric('1'); // -> true
isNumeric(Number.MAX_VALUE); // -> true
isNumeric(0xff); // -> true
isNumeric(''); // -> false
isNumeric('1.1.1'); // -> false
isNumeric(NaN); // -> false
```
## isObj
Check if value is the language type of Object.
Type Definition
function isObj(val: any): boolean;
| Name | Desc |
| ------ | -------------------------- |
| val | Value to check |
| return | True if value is an object |
[Language Spec](http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types)
```javascript
isObj({}); // -> true
isObj([]); // -> true
```
## isOdd
Check if number is odd.
Type Definition
function isOdd(num: number): boolean;
| Name | Desc |
| ------ | --------------------- |
| num | Number to check |
| return | True if number is odd |
```javascript
isOdd(0); // -> false
isOdd(1); // -> true
isOdd(2); // -> false
```
## isPlainObj
Check if value is an object created by Object constructor.
Type Definition
function isPlainObj(val: any): boolean;
| Name | Desc |
| ------ | ------------------------------- |
| val | Value to check |
| return | True if value is a plain object |
```javascript
isPlainObj({}); // -> true
isPlainObj([]); // -> false
isPlainObj(function() {}); // -> false
```
## isPortFree
Check if a TCP port is free.
Type Definition
function isPortFree(
port: number,
host?: string
): Promise<boolean>;
| Name | Desc |
| ------ | -------------------------- |
| port | TCP port |
| host | Host address |
| return | True if given port is free |
```javascript
isPortFree(3000).then(isFree => {
// Do something.
});
```
## isPrime
Check if the provided integer is a prime number.
Type Definition
function isPrime(num: number): boolean;
| Name | Desc |
| ------ | -------------------------------- |
| num | Number to check |
| return | True if number is a prime number |
```javascript
isPrime(11); // -> true
isPrime(8); // -> false
```
## isPrimitive
Check if value is string, number, boolean or null.
Type Definition
function isPrimitive(val: any): boolean;
| Name | Desc |
| ------ | ---------------------------- |
| val | Value to check |
| return | True if value is a primitive |
```javascript
isPrimitive(5); // -> true
isPrimitive('abc'); // -> true
isPrimitive(false); // -> true
```
## isPromise
Check if value looks like a promise.
Type Definition
function isPromise(val: any): boolean;
| Name | Desc |
| ------ | ---------------------------------- |
| val | Value to check |
| return | True if value looks like a promise |
```javascript
isPromise(new Promise(function() {})); // -> true
isPromise({}); // -> false
```
## isRegExp
Check if value is a regular expression.
Type Definition
function isRegExp(val: any): boolean;
| Name | Desc |
| ------ | ------------------------------------- |
| val | Value to check |
| return | True if value is a regular expression |
```javascript
isRegExp(/a/); // -> true
```
## isRelative
Check if path appears to be relative.
Type Definition
function isRelative(path: string): boolean;
| Name | Desc |
| ------ | ----------------------------------- |
| path | Path to check |
| return | True if path appears to be relative |
```javascript
isRelative('README.md'); // -> true
```
## isRetina
Determine if running on a high DPR device or not.
Type Definition
const isRetina: boolean;
```javascript
console.log(isRetina); // -> true if high DPR
```
## isRunning
Check if process is running.
Type Definition
function isRunning(pid: number): boolean;
| Name | Desc |
| ------ | -------------------------- |
| pid | Process id |
| return | True if process is running |
```javascript
isRunning(123456); // true if running
```
## isSet
Check if value is a Set object.
Type Definition
function isSet(val: any): boolean;
| Name | Desc |
| ------ | ---------------------- |
| val | Value to check |
| return | True if value is a Set |
```javascript
isSet(new Set()); // -> true
isSet(new WeakSet()); // -> false
```
## isSorted
Check if an array is sorted.
Type Definition
function isSorted(arr: any[], cmp?: types.AnyFn): boolean;
| Name | Desc |
| ------ | ----------------------- |
| arr | Array to check |
| cmp | Comparator |
| return | True if array is sorted |
```javascript
isSorted([1, 2, 3]); // -> true
isSorted([3, 2, 1]); // -> false
```
## isStr
Check if value is a string primitive.
Type Definition
function isStr(val: any): boolean;
| Name | Desc |
| ------ | ----------------------------------- |
| val | Value to check |
| return | True if value is a string primitive |
```javascript
isStr('zso'); // -> true
```
## isStream
Check if value is a Node.js stream.
Type Definition
function isStream(val: any): boolean;
| Name | Desc |
| ------ | --------------------------------- |
| val | Value to check |
| return | True if value is a Node.js stream |
```javascript
const stream = require('stream');
isStream(new stream.Stream()); // -> true
```
## isSymbol
Check if value is a symbol.
Type Definition
function isSymbol(val: any): boolean;
| Name | Desc |
| ------ | ------------------------- |
| val | Value to check |
| return | True if value is a symbol |
```javascript
isSymbol(Symbol('test')); // -> true
```
## isTypedArr
Check if value is a typed array.
Type Definition
function isTypedArr(val: any): boolean;
| Name | Desc |
| ------ | ------------------------------ |
| val | Value to check |
| return | True if value is a typed array |
```javascript
isTypedArr([]); // -> false
isTypedArr(new Uint8Array(8)); // -> true
```
## isUndef
Check if value is undefined.
Type Definition
function isUndef(val: any): boolean;
| Name | Desc |
| ------ | -------------------------- |
| val | Value to check |
| return | True if value is undefined |
```javascript
isUndef(void 0); // -> true
isUndef(null); // -> false
```
## isUrl
Loosely validate an url.
Type Definition
function isUrl(val: string): boolean;
| Name | Desc |
| ------ | ----------------------------------- |
| val | Value to check |
| return | True if value is an url like string |
```javascript
isUrl('http://www.example.com?foo=bar¶m=test'); // -> true
```
## isWeakMap
Check if value is a WeakMap object.
Type Definition
function isWeakMap(val: any): boolean;
| Name | Desc |
| ------ | -------------------------- |
| val | Value to check |
| return | True if value is a WeakMap |
```javascript
isWeakMap(new Map()); // -> false
isWeakMap(new WeakMap()); // -> true
```
## isWeakSet
Check if value is a WeakSet object.
Type Definition
function isWeakSet(val: any): boolean;
| Name | Desc |
| ------ | -------------------------- |
| val | Value to check |
| return | True if value is a WeakSet |
```javascript
isWeakSet(new Set()); // -> false
isWeakSet(new WeakSet()); // -> true
```
## isWindows
Check if platform is windows.
Type Definition
const isWindows: boolean;
```javascript
console.log(isWindows); // -> true if running on windows
```
## jsonClone
Use JSON parse and stringify to clone object.
Type Definition
function jsonClone<T>(val: T): T;
| Name | Desc |
| ------ | -------------- |
| val | Value to clone |
| return | Cloned value |
```javascript
jsonClone({ name: 'zso' }); // -> { name: 'zso' }
```
## jsonp
A simple jsonp implementation.
Type Definition
function keyCode(name: string): number;
function keyCode(code: number): string;
Get key code's name.
| Name | Desc |
| ------ | ---------------------- |
| code | Key code |
| return | Corresponding key name |
Get key name's code.
| Name | Desc |
| ------ | ---------------------- |
| name | Key name |
| return | Corresponding key code |
```javascript
keyCode(13); // -> 'enter'
keyCode('enter'); // -> 13
```
## keys
Create an array of the own enumerable property names of object.
Type Definition
function keys(obj: any): string[];
| Name | Desc |
| ------ | ----------------------- |
| obj | Object to query |
| return | Array of property names |
```javascript
keys({ a: 1 }); // -> ['a']
```
## kill
Kill process.
Type Definition
function kill(pid: number): void;
| Name | Desc |
| ---- | ---------- |
| pid | Process ID |
```javascript
kill(9420);
```
## last
Get the last element of array.
Type Definition
function last(arr: any[]): any;
| Name | Desc |
| ------ | ------------------------- |
| arr | The array to query |
| return | The last element of array |
```javascript
last([1, 2]); // -> 2
```
## lazyImport
Import modules lazily, Proxy is used.
Type Definition
| Name | Desc |
| -------- | --------------------------------- |
| importFn | Actual function to require module |
| dirname | Current file folder |
| return | New function to require module |
```javascript
const r = lazyImport(require);
const _ = r('underscore');
_.isNumber(5);
```
## lazyRequire
Require modules lazily.
Type Definition
function lazyRequire<T>(
requireFn: (moduleId: string) => T
): (moduleId: string) => T;
```javascript
const r = lazyRequire(require);
const _ = r('underscore');
// underscore is required only when _ is called.
_().isNumber(5);
```
## levenshtein
Levenshtein distance implementation.
Type Definition
function levenshtein(a: string, b: string): number;
| Name | Desc |
| ------ | ------------------------------------ |
| a | First string |
| b | Second string |
| return | Levenshtein distance between a and b |
```javascript
levenshtein('cat', 'cake'); // -> 2
```
## linkify
Hyperlink urls in a string.
Type Definition
function linkify(str: string, hyperlink?: types.AnyFn): string;
| Name | Desc |
| --------- | ------------------------- |
| str | String to hyperlink |
| hyperlink | Function to hyperlink url |
| return | Result string |
```javascript
const str = 'Official site: http://eustia.ooo9.io';
linkify(str); // -> 'Official site: http://eustia.ooo9.io'
linkify(str, function(url) {
return '' + url + '';
});
```
## loadCss
Inject link tag into page with given href value.
Type Definition
function loadCss(src: string, cb?: types.AnyFn): void;
| Name | Desc |
| ---- | --------------- |
| src | Style source |
| cb | Onload callback |
```javascript
loadCss('style.css', function(isLoaded) {
// Do something...
});
```
## loadImg
Load image with given src.
Type Definition
function loadImg(src: string, cb?: types.AnyFn): void;
| Name | Desc |
| ---- | --------------- |
| src | Image source |
| cb | Onload callback |
```javascript
loadImg('http://eustia.ooo9.io/img.jpg', function(err, img) {
console.log(img.width, img.height);
});
```
## loadJs
Inject script tag into page with given src value.
Type Definition
function loadJs(src: string, cb?: types.AnyFn): void;
| Name | Desc |
| ---- | --------------- |
| src | Script source |
| cb | Onload callback |
```javascript
loadJs('main.js', function(isLoaded) {
// Do something...
});
```
## longest
Get the longest item in an array.
Type Definition
function longest(arr: string[]): string;
| Name | Desc |
| ------ | ---------------- |
| arr | Array to inspect |
| return | Longest item |
```javascript
longest(['a', 'abcde', 'abc']); // -> 'abcde'
```
## lowerCase
Convert string to lower case.
Type Definition
function lowerCase(str: string): string;
| Name | Desc |
| ------ | ------------------ |
| str | String to convert |
| return | Lower cased string |
```javascript
lowerCase('TEST'); // -> 'test'
```
## lpad
Pad string on the left side if it's shorter than length.
Type Definition
function lpad(str: string, len: number, chars?: string): string;
| Name | Desc |
| ------ | ---------------------- |
| str | String to pad |
| len | Padding length |
| chars | String used as padding |
| return | Result string |
```javascript
lpad('a', 5); // -> ' a'
lpad('a', 5, '-'); // -> '----a'
lpad('abc', 3, '-'); // -> 'abc'
lpad('abc', 5, 'ab'); // -> 'ababc'
```
## ltrim
Remove chars or white-spaces from beginning of string.
Type Definition
function ltrim(str: string, chars?: string | string[]): string;
| Name | Desc |
| ------ | ------------------ |
| str | String to trim |
| chars | Characters to trim |
| return | Trimmed string |
```javascript
ltrim(' abc '); // -> 'abc '
ltrim('_abc_', '_'); // -> 'abc_'
ltrim('_abc_', ['a', '_']); // -> 'bc_'
```
## map
Create an array of values by running each element in collection through iteratee.
Type Definition
function map<T, TResult>(
list: types.List<T>,
iterator: types.ListIterator<T, TResult>,
context?: any
): TResult[];
function map<T, TResult>(
object: types.Dictionary<T>,
iterator: types.ObjectIterator<T, TResult>,
context?: any
): TResult[];
| Name | Desc |
| -------- | ------------------------------ |
| object | Collection to iterate over |
| iterator | Function invoked per iteration |
| context | Function context |
| return | New mapped array |
```javascript
map([4, 8], function(n) {
return n * n;
}); // -> [16, 64]
```
## mapObj
Map for objects.
Type Definition
function mapObj<T, TResult>(
object: types.Dictionary<T>,
iterator: types.ObjectIterator<T, TResult>,
context?: any
): types.Dictionary<TResult>;
| Name | Desc |
| -------- | ------------------------------ |
| object | Object to iterate over |
| iterator | Function invoked per iteration |
| context | Function context |
| return | New mapped object |
```javascript
mapObj({ a: 1, b: 2 }, function(val, key) {
return val + 1;
}); // -> {a: 2, b: 3}
```
## matcher
Return a predicate function that checks if attrs are contained in an object.
Type Definition
function matcher(attrs: any): types.AnyFn;
| Name | Desc |
| ------ | ---------------------------------- |
| attrs | Object of property values to match |
| return | New predicate function |
```javascript
const filter = require('zso/filter');
const objects = [
{ a: 1, b: 2, c: 3 },
{ a: 4, b: 5, c: 6 }
];
filter(objects, matcher({ a: 4, c: 6 })); // -> [{a: 4, b: 5, c: 6}]
```
## max
Get maximum value of given numbers.
Type Definition
function max(...num: number[]): number;
| Name | Desc |
| ------ | -------------------- |
| ...num | Numbers to calculate |
| return | Maximum value |
```javascript
max(2.3, 1, 4.5, 2); // 4.5
```
## md5
MD5 implementation.
Type Definition
function md5(msg: string | number[]): string;
| Name | Desc |
| ------ | ------------------ |
| msg | Message to encrypt |
| return | MD5 hash |
```javascript
md5('zso'); // -> 'e59f337d85e9a467f1783fab282a41d0'
```
## memStorage
Memory-backed implementation of the Web Storage API.
Type Definition
const memStorage: typeof window.localStorage;
A replacement for environments where localStorage or sessionStorage is not available.
```javascript
const localStorage = window.localStorage || memStorage;
localStorage.setItem('test', 'zso');
```
## memoize
Memoize a given function by caching the computed result.
Type Definition
function memoize(
fn: types.AnyFn,
hashFn?: types.AnyFn
): types.AnyFn;
| Name | Desc |
| ------ | ------------------------------------ |
| fn | Function to have its output memoized |
| hashFn | Function to create cache key |
| return | New memoized function |
```javascript
const fibonacci = memoize(function(n) {
return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
});
```
## mergeArr
Merge the contents of arrays together into the first array.
Type Definition
| Name | Desc |
| ------ | ------------------------------------ |
| first | Array to merge |
| arrays | Arrays to merge into the first array |
| return | First array |
```javascript
const a = [1, 2];
mergeArr(a, [3, 4], [5, 6]);
console.log(a); // -> [1, 2, 3, 4, 5, 6]
```
## mergeSort
Merge sort implementation.
Type Definition
function mergeSort(arr: any[], cmp?: types.AnyFn): any[];
Note: It's not an "in-place" sort.
| Name | Desc |
| ------ | ------------- |
| arr | Array to sort |
| cmp | Comparator |
| return | Sorted array |
```javascript
mergeSort([2, 1]); // -> [1, 2]
```
## meta
Document meta manipulation, turn name and content into key value pairs.
Type Definition
namespace meta {
function remove(nameList: string | string[]): void;
}
function meta(): {};
function meta(key: string): string;
function meta(keys: string[]): {};
function meta(key, value): void;
function meta(pairs: {}): void;
Get meta content with given name. If name is omitted, all pairs will be return.
| Name | Desc |
| ------ | ------------ |
| name | Meta name |
| return | Meta content |
Set meta content.
| Name | Desc |
| ------- | ------------ |
| name | Meta name |
| content | Meta content |
| Name | Desc |
| ----- | ---------------------------- |
| metas | Object of name content pairs |
### remove
Remove metas.
| Name | Desc |
| ---- | --------- |
| name | Meta name |
```javascript
//
meta(); // -> {a: '1', b: '2', c: '3'}
meta('a'); // -> '1'
meta(['a', 'c']); // -> {a: '1', c: '3'}
meta('d', '4');
meta({
d: '5',
e: '6',
f: '7'
});
meta.remove('d');
meta.remove(['e', 'f']);
```
## methods
Return a sorted list of the names of every method in an object.
Type Definition
function methods(obj: any): string[];
| Name | Desc |
| ------ | ------------------------ |
| obj | Object to check |
| return | Function names in object |
```javascript
methods(console); // -> ['Console', 'assert', 'dir', ...]
```
## mime
Common mime types.
Type Definition
function mime(name: string): string | undefined;
| Name | Desc |
| ------ | --------- |
| name | Extension |
| return | Mime type |
| Name | Desc |
| ------ | --------- |
| name | Mime type |
| return | Extension |
It contains only the most common file types.
```javascript
mime('jpg'); // -> 'image/jpeg'
mime('bmp'); // -> 'image/bmp'
mime('video/mp4'); // -> 'mp4'
mime('test'); // -> undefined
```
## min
Get minimum value of given numbers.
Type Definition
function min(...num: number[]): number;
| Name | Desc |
| ------ | -------------------- |
| ...num | Numbers to calculate |
| return | Minimum value |
```javascript
min(2.3, 1, 4.5, 2); // 1
```
## mkdir
Recursively create directories.
Type Definition
namespace mkdir {
function sync(dir: string, mode?: number): void;
}
function mkdir(
dir: string,
mode?: number,
cb?: types.AnyFn
): void;
function mkdir(dir: string, cb?: types.AnyFn): void;
| Name | Desc |
| --------- | ------------------- |
| dir | Directory to create |
| mode=0777 | Directory mode |
| cb | Callback |
### sync
Synchronous version.
```javascript
mkdir('/tmp/foo/bar/baz', function(err) {
if (err) console.log(err);
else console.log('Done');
});
mkdir.sync('/tmp/foo2/bar/baz');
```
## moment
Tiny moment.js like implementation.
Type Definition
namespace moment {
class M {
constructor(value: string | Date);
format(mask: string): string;
isValid(): boolean;
isLeapYear(): boolean;
isSame(that: M): boolean;
valueOf(): number;
isBefore(that: M): boolean;
isAfter(that: M): boolean;
year(): number;
year(number): M;
month(): number;
month(number): M;
date(): number;
date(number): M;
hour(): number;
hour(number): M;
minute(): number;
minute(number): M;
second(): number;
second(number): M;
millisecond(): number;
millisecond(number): M;
unix(): number;
clone(): M;
toDate(): Date;
toArray(): number[];
toJSON(): string;
toISOString(): string;
toObject(): any;
toString(): string;
set(unit: string, num: number): M;
startOf(unit: string): M;
endOf(unit: string): M;
daysInMonth(): number;
add(num: number, unit: string): M;
subtract(num: number, unit: string): M;
diff(input: M | string | Date, unit: string, asFloat: boolean): number;
}
}
function moment(value: string | Date): moment.M;
It only supports a subset of moment.js api.
### Available methods
format, isValid, isLeapYear, isSame, isBefore, isAfter, year,
month, date, hour, minute, second, millisecond, unix, clone,
toDate, toArray, toJSON, toISOString, toObject, toString, set,
startOf, endOf, add, subtract, diff
### Not supported
locale and units like quarter and week.
Note: Format uses dateFormat module, so the mask is not quite the same as moment.js.
```javascript
moment('20180501').format('yyyy-mm-dd'); // -> '2018-05-01'
```
## morphDom
Morph a dom tree to match a target dom tree.
Type Definition
function morphDom(from: Node, to: Node | string): Node;
| Name | Type |
| ------ | ------------------ |
| from | Node to morph |
| to | Node to be morphed |
| return | Morphed node |
```javascript
const el1 = document.createElement('div');
el1.className = 'test';
const el2 = document.createElement('div');
el2.className = 'zso';
morphDom(el1, el2);
console.log(el1.className); // -> 'zso'
```
## morse
Morse code encoding and decoding.
Type Definition
### encode
Turn text into Morse code.
| Name | Desc |
| ------ | -------------- |
| txt | Text to encode |
| return | Morse code |
### decode
Decode Morse code into text.
| Name | Desc |
| ------ | -------------- |
| morse | Morse code |
| return | Decoded string |
```javascript
const str = morse.encode('Hello, world.');
// -> '.... . .-.. .-.. --- --..-- ....... .-- --- .-. .-.. -.. .-.-.-'
morse.decode(str); // -> 'Hello, world.'
```
## ms
Convert time string formats to milliseconds.
Type Definition
function ms(str: string): number;
function ms(num: number): string;
Turn time string into milliseconds.
| Name | Desc |
| ------ | ------------- |
| str | String format |
| return | Milliseconds |
Turn milliseconds into time string.
| Name | Desc |
| ------ | ------------- |
| num | Milliseconds |
| return | String format |
```javascript
ms('1s'); // -> 1000
ms('1m'); // -> 60000
ms('1.5h'); // -> 5400000
ms('1d'); // -> 86400000
ms('1y'); // -> 31557600000
ms('1000'); // -> 1000
ms(1500); // -> '1.5s'
ms(60000); // -> '1m'
```
## naturalSort
Sort values in natural order.
Type Definition
function naturalSort<T extends any[]>(arr: T): T;
| Name | Desc |
| ------ | --------------- |
| arr | Array of values |
| return | Sorted array |
```javascript
naturalSort(['img12', 'img11', '$img', '_img', '1', '2', '12']);
// -> ['1', '2', '12', '$img', 'img11', 'img12', '_img']
naturalSort([2, '1', 13]); // -> ['1', 2, 13]
```
## negate
Create a function that negates the result of the predicate function.
Type Definition
function negate<T extends types.AnyFn>(predicate: T): T;
| Name | Desc |
| --------- | ------------------- |
| predicate | Predicate to negate |
| return | New function |
```javascript
function even(n) {
return n % 2 === 0;
}
[1, 2, 3, 4, 5, 6].filter(negate(even)); // -> [1, 3, 5]
```
## nextTick
Next tick for both node and browser.
Type Definition
function nextTick(cb: types.AnyFn): void;
| Name | Desc |
| ---- | ---------------- |
| cb | Function to call |
Use process.nextTick if available.
Otherwise setImmediate or setTimeout is used as fallback.
```javascript
nextTick(function() {
// Do something...
});
```
## noop
A no-operation function.
Type Definition
function noop(): void;
```javascript
noop(); // Does nothing
```
## normalizeHeader
Normalize http header name.
Type Definition
| Name | Desc |
| ------- | -------------------- |
| title | Notification title |
| options | Notification options |
You can pass exactly the same options supported in the [Web Notification](https://developer.mozilla.org/en-US/docs/Web/API/Notification/Notification).
### Notification
Use this to create instance when certain events like close, show, click or error needed to be handled.
```javascript
notify('zso', {
body: 'This is the notification content'
});
const notification = new notify.Notification('zso', {
body: 'This is the notification content'
});
notification.on('error', err => console.log(err));
notification.on('click', e => console.log(e));
notification.show();
```
## now
Gets the number of milliseconds that have elapsed since the Unix epoch.
Type Definition
function now(): number;
```javascript
now(); // -> 1468826678701
```
## objToStr
Alias of Object.prototype.toString.
Type Definition
function objToStr(val: any): string;
| Name | Desc |
| ------ | ------------------------------------ |
| val | Source value |
| return | String representation of given value |
```javascript
objToStr(5); // -> '[object Number]'
```
## omit
Opposite of pick.
Type Definition
function omit(
obj: any,
filter: string | string[] | Function
): any;
| Name | Desc |
| ------ | ----------------------- |
| fn | Function to restrict |
| return | New restricted function |
```javascript
function init() {}
const initOnce = once(init);
initOnce();
initOnce(); // -> init is invoked once
```
## open
Open stuff like url, files.
Type Definition
function open(target: string): any;
| Name | Desc |
| ------ | ------------- |
| target | Stuff to open |
| return | Child process |
```javascript
open('https://eustia.ooo9.io/');
```
## openFile
Open file dialog to select file in browser.
Type Definition
function openFile(options?: {
accept?: string;
multiple?: boolean;
}): Promise<File[]>;
| Name | Desc |
| ------- | -------------- |
| options | Dialog options |
| return | Files promise |
Available options:
| Name | Desc |
| -------------- | ---------------------------- |
| accept | File types |
| multiple=false | Select multiple files or not |
```javascript
openFile({ multiple: true }).then(fileList => {
console.log(fileList);
});
```
## optimizeCb
Used for function context binding.
Type Definition
function optimizeCb(
fn: types.AnyFn,
ctx: any,
argCount?: number
): types.AnyFn;
## ordinal
Add ordinal indicator to number.
Type Definition
function ordinal(num: number): string;
| Name | Desc |
| ------ | ----------------------- |
| num | Number to add indicator |
| return | Result ordinal number |
```javascript
ordinal(1); // -> '1st'
ordinal(2); // -> '2nd'
```
## orientation
Screen orientation helper.
Type Definition
### on
Bind change event.
### off
Unbind change event.
### get
Get current orientation(landscape or portrait).
```javascript
orientation.on('change', function(direction) {
console.log(direction); // -> 'portrait'
});
orientation.get(); // -> 'landscape'
```
## pad
Pad string on the left and right sides if it's shorter than length.
Type Definition
function pad(str: string, len: number, chars?: string): string;
| Name | Desc |
| ------ | ---------------------- |
| str | String to pad |
| len | Padding length |
| chars | String used as padding |
| return | Result string |
```javascript
pad('a', 5); // -> ' a '
pad('a', 5, '-'); // -> '--a--'
pad('abc', 3, '-'); // -> 'abc'
pad('abc', 5, 'ab'); // -> 'babca'
pad('ab', 5, 'ab'); // -> 'ababa'
```
## pairs
Convert an object into a list of [key, value] pairs.
Type Definition
function pairs(obj: any): Array<any[]>;
| Name | Desc |
| ------ | -------------------------- |
| obj | Object to convert |
| return | List of [key, value] pairs |
```javascript
pairs({ a: 1, b: 2 }); // -> [['a', 1], ['b', 2]]
```
## parallel
Run an array of functions in parallel.
Type Definition
function parallel(tasks: types.AnyFn[], cb?: types.AnyFn): void;
| Name | Desc |
| ----- | ----------------------- |
| tasks | Array of functions |
| cb | Callback once completed |
```javascript
parallel(
[
function(cb) {
setTimeout(function() {
cb(null, 'one');
}, 200);
},
function(cb) {
setTimeout(function() {
cb(null, 'two');
}, 100);
}
],
function(err, results) {
// results -> ['one', 'two']
}
);
```
## parseArgs
Parse command line argument options, the same as minimist.
Type Definition
| Name | Desc |
| ------- | ------------- |
| html | Html to parse |
| handler | Handlers |
```javascript
parseHtml('
zso
', {
start: (tag, attrs, unary) => {},
end: tag => {},
comment: text => {},
text: text => {}
});
```
## partial
Partially apply a function by filling in given arguments.
Type Definition
function partial(
fn: types.AnyFn,
...partials: any[]
): types.AnyFn;
| Name | Desc |
| ----------- | ---------------------------------------- |
| fn | Function to partially apply arguments to |
| ...partials | Arguments to be partially applied |
| return | New partially applied function |
```javascript
const sub5 = partial(function(a, b) {
return b - a;
}, 5);
sub5(20); // -> 15
```
## pascalCase
Convert string to "pascalCase".
Type Definition
function pascalCase(str: string): string;
| Name | Desc |
| ------ | ------------------- |
| str | String to convert |
| return | Pascal cased string |
```javascript
pascalCase('fooBar'); // -> FooBar
pascalCase('foo bar'); // -> FooBar
pascalCase('foo_bar'); // -> FooBar
pascalCase('foo.bar'); // -> FooBar
```
## perfNow
High resolution time up to microsecond precision.
Type Definition
function perfNow(): number;
```javascript
const start = perfNow();
// Do something.
console.log(perfNow() - start);
```
## pick
Return a filtered copy of an object.
Type Definition
function pick(
object: any,
filter: string | string[] | Function
): any;
import stream = require('stream');
function pipe(...streams: stream.Stream[]): void;
| Name | Desc |
| ---------- | --------------- |
| ...streams | Streams to pipe |
```javascript
const fs = require('fs');
const through = require('zso/through');
pipe(
fs.createReadStream('in.txt'),
through(function(chunk, enc, cb) {
this.push(chunk);
cb();
}),
fs.createWriteStream('out.txt')
);
```
## pluck
Extract a list of property values.
Type Definition
function pluck(object: any, key: string | string[]): any[];
| Name | Desc |
| ------ | ------------------------------- |
| obj | Collection to iterate over |
| key | Property path |
| return | New array of specified property |
```javascript
const stooges = [
{ name: 'moe', age: 40 },
{ name: 'larry', age: 50 },
{ name: 'curly', age: 60 }
];
pluck(stooges, 'name'); // -> ['moe', 'larry', 'curly']
```
## precision
Find decimal precision of a given number.
Type Definition
function precision(num: number): number;
| Name | Desc |
| ------ | --------------- |
| num | Number to check |
| return | Precision |
```javascript
precision(1.234); // -> 3;
```
## prefetch
Fetch a given url.
Type Definition
function prefetch(url: string): Promise<void>;
| Name | Desc |
| ---- | --------------- |
| url | Url to prefetch |
It uses `` if possible.
```javascript
prefetch('https://eustia.ooo9.io/');
```
## prefix
Add vendor prefixes to a CSS attribute.
Type Definition
namespace prefix {
function dash(name: string): string;
}
function prefix(name: string): string;
| Name | Desc |
| ------ | ---------------------- |
| name | Property name |
| return | Prefixed property name |
### dash
Create a dasherize version.
```javascript
prefix('text-emphasis'); // -> 'WebkitTextEmphasis'
prefix.dash('text-emphasis'); // -> '-webkit-text-emphasis'
prefix('color'); // -> 'color'
```
## promisify
Convert callback based functions into Promises.
Type Definition
function promisify(
fn: types.AnyFn,
multiArgs?: boolean
): types.AnyFn;
| Name | Desc |
| --------------- | -------------------------------------- |
| fn | Callback based function |
| multiArgs=false | If callback has multiple success value |
| return | Result function |
If multiArgs is set to true, the resulting promise will always fulfill with an array of the callback's success values.
```javascript
const fs = require('fs');
const readFile = promisify(fs.readFile);
readFile('test.js', 'utf-8').then(function(data) {
// Do something with file content.
});
```
## property
Return a function that will itself return the key property of any passed-in object.
Type Definition
function property(path: string | string[]): types.AnyFn;
| Name | Desc |
| ------ | --------------------------- |
| path | Path of the property to get |
| return | New accessor function |
```javascript
const obj = { a: { b: 1 } };
property('a')(obj); // -> {b: 1}
property(['a', 'b'])(obj); // -> 1
```
## query
Parse and stringify url query strings.
Type Definition
namespace raf {
function cancel(id: number): void;
}
function raf(cb: types.AnyFn): number;
Use setTimeout if native requestAnimationFrame is not supported.
```javascript
const id = raf(function tick() {
// Animation stuff
raf(tick);
});
raf.cancel(id);
```
## random
Produces a random number between min and max(inclusive).
Type Definition
function random(
min: number,
max?: number,
floating?: boolean
): number;
| Name | Desc |
| -------------- | ---------------------- |
| min | Minimum possible value |
| max | Maximum possible value |
| floating=false | Float or not |
| return | Random number |
```javascript
random(1, 5); // -> an integer between 0 and 5
random(5); // -> an integer between 0 and 5
random(1.2, 5.2, true); /// -> a floating-point number between 1.2 and 5.2
```
## randomBytes
Random bytes generator.
Type Definition
function randomBytes(size: number): Uint8Array;
Use crypto module in node or crypto object in browser if possible.
| Name | Desc |
| ------ | ---------------------------- |
| size | Number of bytes to generate |
| return | Random bytes of given length |
```javascript
randomBytes(5); // -> [55, 49, 153, 30, 122]
```
## randomColor
Random color generator.
Type Definition
function randomColor(): string;
function randomColor(options: {
count?: number;
hue?: number;
lightness?: number;
format?: string;
seed?: number;
}): string | string[];
| Name | Desc |
| ------- | -------------- |
| options | Random options |
| return | Random color |
Available options:
| Name | Desc |
| ---------- | --------------------------------- |
| count=1 | Color number |
| hue | Hue, number between 0 and 360 |
| lightness | Lightness, number between 0 and 1 |
| format=hex | Color format, hex, hsl or rgb |
| seed | Random color seed |
```javascript
randomColor({
count: 2
}); // -> ['#fed7f4', '#526498']
```
## randomId
A tiny id generator, similar to nanoid.
Type Definition
function randomId(size?: number, symbols?: string): string;
| Name | Desc |
| ------- | ----------------------------------------------------- |
| size=21 | Id size |
| symbols | Symbols used to generate ids, a-zA-Z0-9\_- by default |
```javascript
randomId(); // -> 'oKpy4HwU8E6IvU5I03gyQ'
randomId(5); // -> 'sM6E9'
randomId(5, 'abc'); // -> 'cbbcb'
```
## randomItem
Get a random item from an array.
Type Definition
function randomItem(arr: any[]): any;
| Name | Desc |
| ------ | -------------------- |
| arr | Array to get |
| return | Randomly picked item |
```javascript
randomItem([1, 2, 3]); // -> 2
```
## range
Create flexibly-numbered lists of integers.
Type Definition
function range(
start: number,
end?: number,
step?: number
): number[];
| Name | Desc |
| ------ | ---------------------------------- |
| start | Start of the range |
| end | End of the range |
| step=1 | Value to increment or decrement by |
| return | List of integers |
```javascript
range(5); // -> [0, 1, 2, 3, 4]
range(0, 5, 2); // -> [0, 2, 4]
```
## rc4
RC4 symmetric encryption implementation.
Type Definition
### encrypt
RC4 encryption, result as base64 string.
### decrypt
RC4 decryption, pass base64 string as input.
| Name | Desc |
| ------ | -------------------------------- |
| key | Secret key |
| str | String to be encrypted/decrypted |
| return | Encrypted/decrypted string |
```javascript
rc4.encrypt('zso', 'Hello world'); // -> 'j9y2VpSfR3AdNN8='
rc4.decrypt('zso', 'j9y2VpSfR3AdNN8='); // -> 'Hello world'
```
## ready
Invoke callback when dom is ready, similar to jQuery ready.
Type Definition
function ready(fn: types.AnyFn): void;
| Name | Desc |
| ---- | ----------------- |
| fn | Callback function |
```javascript
ready(function() {
// It's safe to manipulate dom here.
});
```
## reduce
Turn a list of values into a single value.
Type Definition
function reduce<T, TResult>(
list: types.List<T>,
iterator: types.MemoIterator<T, TResult>,
memo?: TResult,
context?: any
): TResult;
function reduce<T, TResult>(
list: types.Dictionary<T>,
iterator: types.MemoObjectIterator<T, TResult>,
memo?: TResult,
context?: any
): TResult;
| Name | Desc |
| ----------------- | ------------------------------ |
| obj | Collection to iterate over |
| iterator=identity | Function invoked per iteration |
| initial | Initial value |
| ctx | Function context |
| return | Accumulated value |
```javascript
reduce(
[1, 2, 3],
function(sum, n) {
return sum + n;
},
0
); // -> 6
```
## reduceRight
Right-associative version of reduce.
Type Definition
function reduceRight<T, TResult>(
list: types.Collection<T>,
iterator: types.MemoIterator<T, TResult>,
memo?: TResult,
context?: any
): TResult;
```javascript
reduceRight(
[[1], [2], [3]],
function(a, b) {
return a.concat(b);
},
[]
); // -> [3, 2, 1]
```
## reject
Opposite of filter.
Type Definition
function reject<T>(
list: types.List<T>,
iterator: types.ListIterator<T, boolean>,
context?: any
): T[];
function reject<T>(
object: types.Dictionary<T>,
iterator: types.ObjectIterator<T, boolean>,
context?: any
): T[];
| Name | Desc |
| --------- | ---------------------------------------------- |
| obj | Collection to iterate over |
| predicate | Function invoked per iteration |
| ctx | Predicate context |
| return | Array of all values that didn't pass predicate |
```javascript
reject([1, 2, 3, 4, 5], function(val) {
return val % 2 === 0;
}); // -> [1, 3, 5]
```
## remove
Remove all elements from array that predicate returns truthy for and return an array of the removed elements.
Type Definition
function remove<T, TResult>(
list: types.List<T>,
iterator: types.ListIterator<T, boolean>,
context?: any
): TResult[];
Unlike filter, this method mutates array.
| Name | Desc |
| -------- | ------------------------------------ |
| list | Collection to iterate over |
| iterator | Function invoked per iteration |
| context | Predicate context |
| return | Array of all values that are removed |
```javascript
const arr = [1, 2, 3, 4, 5];
const evens = remove(arr, function(val) {
return val % 2 === 0;
});
console.log(arr); // -> [1, 3, 5]
console.log(evens); // -> [2, 4]
```
## repeat
Repeat string n-times.
Type Definition
function repeat(str: string, n: number): string;
| Name | Desc |
| ------ | ---------------- |
| str | String to repeat |
| n | Repeat times |
| return | Repeated string |
```javascript
repeat('a', 3); // -> 'aaa'
repeat('ab', 2); // -> 'abab'
repeat('*', 0); // -> ''
```
## replaceAll
Replace all instance in a string.
Type Definition
function replaceAll(
str: string,
substr: string,
newSubstr: string
): string;
| Name | Desc |
| --------- | ----------------------------------- |
| str | Source string |
| substr | String to be replaced |
| newSubstr | String to replace substr |
| return | New string with all substr replaced |
```javascript
replaceAll('hello world goodbye world', 'world', 'zso'); // -> 'hello zso goodbye zso'
```
## restArgs
This accumulates the arguments passed into an array, after a given index.
Type Definition
function restArgs(
fn: types.AnyFn,
startIndex?: number
): types.AnyFn;
| Name | Desc |
| ---------- | --------------------------------------- |
| function | Function that needs rest parameters |
| startIndex | The start index to accumulates |
| return | Generated function with rest parameters |
```javascript
const paramArr = restArgs(function(rest) {
return rest;
});
paramArr(1, 2, 3, 4); // -> [1, 2, 3, 4]
```
## reverse
Reverse array without mutating it.
Type Definition
namespace ric {
function cancel(id: number): void;
}
function ric(cb: types.AnyFn): number;
Use setTimeout if requestIdleCallback is not supported.
```javascript
const id = ric(function() {
// Called during a browser's idle periods
});
ric.cancel(id);
```
## rmCookie
Loop through all possible path and domain to remove cookie.
Type Definition
| Name | Desc |
| ------------- | ---------------------------------------------- |
| seed | Random seed |
| min=0 | Min possible value |
| max=1 | Maximum possible value |
| floating=true | Float or not |
| return | Function that generates random number sequence |
```javascript
const random = seedRandom(19920719, 0, 100, false);
random(); // -> 7
random(); // -> 68
```
## selectionSort
Selection sort implementation.
Type Definition
function selectionSort(arr: any[], cmp?: types.AnyFn): any[];
function shellSort(arr: any[], cmp?: types.AnyFn): any[];
| Name | Desc |
| ------ | ------------- |
| arr | Array to sort |
| cmp | Comparator |
| return | Sorted array |
```javascript
shellSort([2, 1]); // -> [1, 2]
```
## shuffle
Randomize the order of the elements in a given array.
Type Definition
function shuffle(arr: any[]): any[];
| Name | Desc |
| ------ | ------------------ |
| arr | Array to randomize |
| return | Randomized Array |
```javascript
shuffle([1, 2, 3]); // -> [3, 1, 2]
```
## size
Get size of object or length of array like object.
Type Definition
function size(obj: any): number;
| Name | Desc |
| ------ | --------------------- |
| obj | Collection to inspect |
| return | Collection size |
```javascript
size({ a: 1, b: 2 }); // -> 2
size([1, 2, 3]); // -> 3
```
## sizeof
Get approximate size of a js object.
Type Definition
function sizeof(obj: any): number;
| Name | Desc |
| ------ | ------------------- |
| obj | Object to calculate |
| return | Size in bytes |
A char of string is counted as 2 bytes. And 4 bytes for boolean, 8 bytes for number.
Object keys are treated as strings.
```javascript
sizeof('a'); // -> 2
sizeof(8); // -> 8
sizeof(false); // -> 4
sizeof(function() {}); // -> 0
sizeof({ a: 'b' }); // -> 4
```
## sleep
Resolve a promise after a specified timeout.
Type Definition
function sleep(timeout: number): Promise<void>;
| Name | Desc |
| ------- | ------------- |
| timeout | Sleep timeout |
```javascript
(async function() {
await sleep(2000);
})();
```
## slice
Create slice of source array or array-like object.
Type Definition
function slice(
array: any[],
start?: number,
end?: number
): any[];
| Name | Desc |
| ---------------- | -------------------------- |
| array | Array to slice |
| start=0 | Start position |
| end=array.length | End position, not included |
```javascript
slice([1, 2, 3, 4], 1, 2); // -> [2]
```
## slugify
Slugify a string.
Type Definition
| Name | Desc |
| ------ | ------------------ |
| str | String to convert |
| return | Snake cased string |
```javascript
snakeCase('fooBar'); // -> foo_bar
snakeCase('foo bar'); // -> foo_bar
snakeCase('foo.bar'); // -> foo_bar
```
## some
Check if predicate return truthy for any element.
Type Definition
function some<T>(
list: types.List<T>,
iterator?: types.ListIterator<T, boolean>,
context?: any
): boolean;
function some<T>(
object: types.Dictionary<T>,
iterator?: types.ObjectIterator<T, boolean>,
context?: any
): boolean;
| Name | Desc |
| --------- | ---------------------------------------------- |
| obj | Collection to iterate over |
| predicate | Function to invoked per iteration |
| ctx | Predicate context |
| return | True if any element passes the predicate check |
```javascript
some([2, 5], function(val) {
return val % 2 === 0;
}); // -> true
```
## sortBy
Return an array of elements sorted in ascending order by results of running each element through iteratee.
Type Definition
function sortBy(
arr: any,
iterator?: types.AnyFn,
ctx?: any
): any[];
| Name | Desc |
| ----------------- | -------------------------- |
| arr | Collection to iterate over |
| iterator=identity | Iterator to sort by |
| ctx | Iterator context |
| return | New sorted array |
```javascript
sortBy([1, 2, 3, 4, 5, 6], function(num) {
return Math.sin(num);
}); // -> [5, 4, 6, 3, 1, 2]
```
## sortKeys
Sort keys of an object.
Type Definition
| Name | Desc |
| ------ | ------------------ |
| str | String to convert |
| return | Space cased string |
```javascript
spaceCase('fooBar'); // -> foo bar
spaceCase('foo.bar'); // -> foo bar
spaceCase('foo.bar'); // -> foo bar
```
## splitCase
Split different string case to an array.
Type Definition
function splitCase(str: string): string[];
| Name | Desc |
| ------ | --------------- |
| str | String to split |
| return | Result array |
```javascript
splitCase('foo-bar'); // -> ['foo', 'bar']
splitCase('foo bar'); // -> ['foo', 'bar']
splitCase('foo_bar'); // -> ['foo', 'bar']
splitCase('foo.bar'); // -> ['foo', 'bar']
splitCase('fooBar'); // -> ['foo', 'bar']
splitCase('foo-Bar'); // -> ['foo', 'bar']
```
## splitPath
Split path into dir, name and ext.
Type Definition
| Name | Desc |
| ------ | ----------------------------------- |
| path | Path to split |
| return | Object containing dir, name and ext |
```javascript
splitPath('f:/foo/bar.txt'); // -> {dir: 'f:/foo/', name: 'bar.txt', ext: '.txt'}
splitPath('/home/foo/bar.txt'); // -> {dir: '/home/foo/', name: 'bar.txt', ext: '.txt'}
```
## stackTrace
Get CallSite objects in v8.
Type Definition
function stackTrace(): any[];
[Stack trace API](https://v8.dev/docs/stack-trace-api)
```javascript
stackTrace(); // -> List of CallSite objects
```
## startWith
Check if string starts with the given target string.
Type Definition
function startWith(str: string, prefix: string): boolean;
| Name | Desc |
| ------ | --------------------------------- |
| str | String to search |
| prefix | String prefix |
| return | True if string starts with prefix |
```javascript
startWith('ab', 'a'); // -> true
```
## strHash
String hash function using djb2.
Type Definition
function strHash(str: string): number;
| Name | Desc |
| ------ | -------------- |
| str | String to hash |
| return | Hash result |
```javascript
strHash('test'); // -> 2090770981
```
## strToBytes
Convert string into bytes.
Type Definition
function strToBytes(str: string, encoding?: string): number[];
| Name | Desc |
| ------- | ------------------- |
| obj | Object to stringify |
| options | Stringify options |
| return | Stringified object |
Available options:
| Name | Desc |
| ------------------ | ------------------------- |
| unenumerable=false | Include unenumerable keys |
| symbol=false | Include symbol keys |
| accessGetter=false | Access getter value |
| timeout=0 | Timeout of stringify |
| depth=0 | Max depth of recursion |
| ignore | Values to ignore |
When time is out, all remaining values will all be "Timeout".
### parse
Parse result string back to object.
| Name | Type |
| ------ | --------------- |
| obj | String to parse |
| return | Result object |
```javascript
stringifyAll(function test() {}); // -> '{"value":"function test() {}","type":"Function",...}'
```
## stripAnsi
Strip ansi codes from a string.
Type Definition
function stripAnsi(str: string): string;
| Name | Desc |
| ------ | --------------- |
| str | String to strip |
| return | Result string |
```javascript
stripAnsi('\u001b[4mcake\u001b[0m'); // -> 'cake'
```
## stripCmt
Strip comments from source code.
Type Definition
function stripCmt(str: string): string;
| Name | Desc |
| ------ | --------------------- |
| str | Source code |
| return | Code without comments |
```javascript
stripCmt('// comment \n var a = 5; /* comment2\n * comment3\n */'); // -> ' var a = 5; '
```
## stripColor
Strip ansi color codes from a string.
Type Definition
function stripColor(str: string): string;
| Name | Desc |
| ------ | --------------- |
| str | String to strip |
| return | Result string |
```javascript
stripColor('\u001b[31mred\u001b[39m'); // -> 'red'
```
## stripHtmlTag
Strip html tags from a string.
Type Definition
function stripHtmlTag(str: string): string;
| Name | Desc |
| ------ | --------------- |
| str | String to strip |
| return | Result string |
```javascript
stripHtmlTag('
Hello
'); // -> 'Hello'
```
## stripIndent
Strip indentation from multi-line strings.
Type Definition
function stripIndent(str: string): string;
function stripIndent(
literals: TemplateStringsArray,
...placeholders: any[]
): string;
| Name | Desc |
| ------ | --------------- |
| str | String to strip |
| return | Result string |
It can be used as function or template tag.
```javascript
stripIndent`
Test string
* item one
* item two
`; // -> 'Test string\n * item one\n * item two'
```
## stripNum
Strip number to a specified precision.
Type Definition
function stripNum(num: number, precision?: number): number;
| Name | Desc |
| ------------ | --------------- |
| num | Number to strip |
| precision=12 | Precision |
| return | Result number |
```javascript
stripNum(0.1 + 0.2); // -> 0.3
```
## sum
Compute sum of given numbers.
Type Definition
function sum(...num: number[]): number;
| Name | Desc |
| ------ | -------------------- |
| ...num | Numbers to calculate |
| return | Sum of numbers |
```javascript
sum(1, 2, 5); // -> 8
```
## swap
Swap two items in an array.
Type Definition
function swap(arr: any[], a: number, b: number): any[];
| Name | Desc |
| ------ | ------------- |
| arr | Array to swap |
| a | First index |
| b | Second index |
| return | Array given |
```javascript
const arr = [1, 2];
swap(arr, 0, 1); // -> [2, 1]
```
## table
Output table string.
Type Definition
function table(rows: Array<string[]>): string;
| Name | Desc |
| ------ | ------------ |
| rows | Table data |
| return | Table string |
```javascript
table([
['', 'firstName', 'lastName'],
['daughter', 'Emily', 'Smith'],
['father', 'John', 'Smith'],
['mother', 'Jane', 'Smith']
]);
```
## template
Compile JavaScript template into function that can be evaluated for rendering.
Type Definition
function template(str: string, util?: any): types.AnyFn;
'
```
## throttle
Return a new throttled version of the passed function.
Type Definition
function throttle<T extends types.AnyFn>(fn: T, wait: number): T;
| Name | Desc |
| ------ | ------------------------------- |
| fn | Function to throttle |
| wait | Number of milliseconds to delay |
| return | New throttled function |
```javascript
const updatePos = throttle(function() {}, 100);
// $(window).scroll(updatePos);
```
## through
Tiny wrapper of stream Transform.
Type Definition
| Name | Desc |
| --------- | ---------------------------- |
| opts={} | Options to initialize stream |
| transform | Transform implementation |
| flush | Flush implementation |
### obj
Shortcut for setting objectMode to true.
### ctor
Return a class that extends stream Transform.
```javascript
const fs = require('fs');
fs.createReadStream('in.txt')
.pipe(
through(function(chunk, enc, cb) {
// Do something to chunk
this.push(chunk);
cb();
})
)
.pipe(fs.createWriteStream('out.txt'));
```
## timeAgo
Format datetime with \*\*\* time ago statement.
Type Definition
function timeAgo(
date: Date | number,
now?: Date | number
): string;
| Name | Desc |
| ------------ | ------------------------- |
| date | Date to calculate |
| now=new Date | Current date |
| return | Formatted time ago string |
```javascript
const now = new Date().getTime();
timeAgo(now - 1000 * 6); // -> just now
timeAgo(now - 1000 * 15); // -> 15 seconds ago
timeAgo(now + 1000 * 60 * 15); // -> in 15 minutes
timeAgo(now - 1000 * 60 * 60 * 5, now); // -> 5 hours ago
```
## timeTaken
Get execution time of a function.
Type Definition
function timeTaken(fn: types.AnyFn): number;
| Name | Desc |
| ------ | ------------------------ |
| fn | Function to measure time |
| return | Execution time, ms |
```javascript
timeTaken(function() {
// Do something.
}); // -> Time taken to execute given function.
```
## times
Invoke given function n times.
Type Definition
function times<T>(
n: number,
fn: (n: number) => T,
ctx?: any
): T[];
| Name | Desc |
| ------ | ------------------------------ |
| n | Times to invoke function |
| fn | Function invoked per iteration |
| ctx | Function context |
| return | Array of results |
```javascript
times(3, String); // -> ['0', '1', '2']
```
## toArr
Convert value to an array.
Type Definition
function toArr(val: any): any[];
| Name | Desc |
| ------ | ---------------- |
| val | Value to convert |
| return | Converted array |
```javascript
toArr({ a: 1, b: 2 }); // -> [{a: 1, b: 2}]
toArr('abc'); // -> ['abc']
toArr(1); // -> [1]
toArr(null); // -> []
```
## toAsync
Use generator like async/await.
Type Definition
function toAsync(fn: types.AnyFn): types.AnyFn;
| Name | Desc |
| ------ | ------------------ |
| fn | Generator function |
| return | Result function |
```javascript
const sleep = require('zso/sleep');
const fn = toAsync(function*() {
yield sleep(200);
return 'zso';
});
fn().then(str => {});
```
## toBool
Convert value to a boolean.
Type Definition
function toBool(val: any): boolean;
| Name | Desc |
| ------ | ----------------- |
| val | Value to convert |
| return | Converted boolean |
```javascript
toBool(true); // -> true
toBool(null); // -> false
toBool(1); // -> true
toBool(0); // -> false
toBool('0'); // -> false
toBool('1'); // -> true
toBool('false'); // -> false
```
## toDate
Convert value to a Date.
Type Definition
function toDate(val: any): Date;
| Name | Desc |
| ------ | ---------------- |
| val | Value to convert |
| return | Converted Date |
```javascript
toDate('20180501');
toDate('2018-05-01');
toDate(1525107450849);
```
## toEl
Convert html string to dom elements.
Type Definition
function toEl(str: string): Element;
There should be only one root element.
| Name | Desc |
| ------ | ------------ |
| str | Html string |
| return | Html element |
```javascript
toEl('
test
');
```
## toInt
Convert value to an integer.
Type Definition
function toInt(val: any): number;
| Name | Desc |
| ------ | ----------------- |
| val | Value to convert |
| return | Converted integer |
```javascript
toInt(1.1); // -> 1
toInt(undefined); // -> 0
```
## toNum
Convert value to a number.
Type Definition
function toNum(val: any): number;
| Name | Desc |
| ------ | ---------------- |
| val | Value to process |
| return | Result number |
```javascript
toNum('5'); // -> 5
```
## toSrc
Convert function to its source code.
Type Definition
function toSrc(fn: types.AnyFn): string;
| Name | Desc |
| ------ | ------------------- |
| fn | Function to convert |
| return | Source code |
```javascript
toSrc(Math.min); // -> 'function min() { [native code] }'
toSrc(function() {}); // -> 'function () { }'
```
## toStr
Convert value to a string.
Type Definition
function toStr(val: any): string;
| Name | Desc |
| ------ | ---------------- |
| val | Value to convert |
| return | Result string |
```javascript
toStr(null); // -> ''
toStr(1); // -> '1'
toStr(false); // -> 'false'
toStr([1, 2, 3]); // -> '1,2,3'
```
## topoSort
Topological sorting algorithm.
Type Definition
### pack
Package a directory into a wxvpkg file
| Name | Desc |
| ---------- | ------------------------------------------------------------------ |
| sourceDir | The directory to work with |
| targetPath | The target path, The default path is the same as the sourceDir |
| targetName | The target filename, The default name is the same as the sourceDir |
| return | pathLike string |
### unpack
Extract a wxvpkg file
| Name | Desc |
| ---------- | ------------------------ |
| pkgPath | The pkgPath to work with |
| targetPath | targetPath |
| return | pathLike string |
```javascript
const tpkg = require('zso/tpkg');
const res = tpkg.pack('path/to/dir/');
const res = tpkg.pack('path/to/dir/', 'path/to/dir/demo');
const res = tpkg.pack('path/to/dir/', 'path/to/dir/demo', 'demo.wxvpkg'); // or demo.tqapkg
//==> eg: path/to/dir/demo.wxvpkg
const res = tpkg.unpack('path/to/dir/demo.wxvpkg', _dirname); // or demo.tqapkg
//==> eg: ${_dirname}/demo/**
```
## trigger
Trigger browser events.
Type Definition
function trigger(
el: Element | Document,
type: string,
options?: any
): void;
function trigger(type: string, options?: any): void;
| Name | Desc |
| ----------- | ------------------ |
| el=document | Element to trigger |
| type | Event type |
| options | Options |
```javascript
trigger(document.getElementById('test'), 'mouseup');
trigger('keydown', { keyCode: 65 });
```
## trim
Remove chars or white-spaces from beginning end of string.
Type Definition
function trim(str: string, chars?: string | string[]): string;
| Name | Desc |
| ------ | ------------------ |
| str | String to trim |
| chars | Characters to trim |
| return | Trimmed string |
```javascript
trim(' abc '); // -> 'abc'
trim('_abc_', '_'); // -> 'abc'
trim('_abc_', ['a', 'c', '_']); // -> 'b'
```
## truncate
Truncate a string to a specific width.
Type Definition
| Name | Desc |
| ------- | --------------------- |
| txt | Text to truncate |
| width | Maximum string length |
| options | Options object |
| return | Truncated string |
Options:
| Name | Desc |
| -------------- | ---------------------------------- |
| ellipsis='...' | String to indicate text is omitted |
| separator | Separator pattern to truncate to |
```javascript
truncate('ORA ORA ORA ORA ORA ORA', 12); // -> 'ORA ORA O...'
truncate('ORA ORA ORA ORA ORA ORA', 10, {
separator: ' ',
ellipsis: '……'
}); // -> 'ORA ORA……'
```
## tryIt
Run function in a try catch.
Type Definition
function tryIt(fn: types.AnyFn, cb?: types.AnyFn): void;
| Name | Desc |
| ---- | --------------------- |
| fn | Function to try catch |
| cb | Callback |
```javascript
tryIt(
function() {
// Do something that might cause an error.
},
function(err, result) {
if (err) console.log(err);
}
);
```
## type
Determine the internal JavaScript [[Class]] of an object.
Type Definition
function type(val: any, lowerCase?: boolean): string;
| Name | Desc |
| -------------- | ----------------- |
| val | Value to get type |
| lowerCase=true | LowerCase result |
| return | Type of object |
```javascript
type(5); // -> 'number'
type({}); // -> 'object'
type(function() {}); // -> 'function'
type([]); // -> 'array'
type([], false); // -> 'Array'
type(async function() {}, false); // -> 'AsyncFunction'
```
## types
Used for typescript definitions only.
Type Definition
### start
Start handling of errors.
### stop
Stop handling.
### addListener
Add listener for handling errors.
| Name | Desc |
| ---- | -------------- |
| fn | Error listener |
### rmListener
Remove listener.
### rmAllListeners
Remove all listeners.
```javascript
uncaught.start();
uncaught.addListener(err => {
// Do something.
});
```
## unescape
Convert HTML entities back, the inverse of escape.
Type Definition
function unescape(str: string): string;
| Name | Desc |
| ------ | ------------------ |
| str | String to unescape |
| return | Unescaped string |
```javascript
unescape('You & Me'); // -> 'You & Me'
```
## union
Create an array of unique values, in order, from all given arrays.
Type Definition
function union(...arr: Array<any[]>): any[];
| Name | Desc |
| ------ | ---------------------------- |
| ...arr | Arrays to inspect |
| return | New array of combined values |
```javascript
union([2, 1], [4, 2], [1, 2]); // -> [2, 1, 4]
```
## uniqId
Generate a globally-unique id.
Type Definition
function uniqId(prefix?: string): string;
| Name | Desc |
| ------ | ------------------ |
| prefix | Id prefix |
| return | Globally-unique id |
```javascript
uniqId('eustia_'); // -> 'eustia_xxx'
```
## unique
Create duplicate-free version of an array.
Type Definition
function unique(
arr: any[],
cmp?: (a: any, b: any) => boolean | number
): any[];
| Name | Desc |
| ------ | ----------------------------- |
| arr | Array to inspect |
| cmp | Function for comparing values |
| return | New duplicate free array |
```javascript
unique([1, 2, 3, 1]); // -> [1, 2, 3]
```
## universalify
Make an async function support both promises and callbacks.
Type Definition
function universalify(
fn: types.AnyFn,
type: string
): types.AnyFn;
| Name | Desc |
| ------ | -------------------------------- |
| fn | Async function |
| type | Source type, promise or callback |
| return | Result function |
```javascript
function callbackFn(str, cb) {
setTimeout(() => {
cb(null, str);
}, 10);
}
const fn = universalify(callbackFn, 'callback');
fn('zso', (err, result) => {
console.log(result); // -> 'zso'
});
fn('zso').then(result => {
console.log(result); // -> 'zso'
});
```
## unzip
Opposite of zip.
Type Definition
declare function unzip(arr: Array<any[]>): Array<any[]>;
| Name | Desc |
| ------ | ------------------------------------ |
| arr | Array of grouped elements to process |
| return | New array of regrouped elements |
```javascript
unzip([
['a', 1, true],
['b', 2, false]
]); // -> [['a', 'b'], [1, 2], [true, false]]
```
## upperCase
Convert string to upper case.
Type Definition
function upperCase(str: string): string;
| Name | Desc |
| ------ | ----------------- |
| str | String to convert |
| return | Uppercased string |
```javascript
upperCase('test'); // -> 'TEST'
```
## upperFirst
Convert the first character of string to upper case.
Type Definition
function upperFirst(str: string): string;
| Name | Desc |
| ------ | ----------------- |
| str | String to convert |
| return | Converted string |
```javascript
upperFirst('red'); // -> Red
```
## use
Use modules that is created by define.
Type Definition
function use(requires: string[], method: types.AnyFn): void;
function use(method: types.AnyFn): void;
| Name | Desc |
| -------- | -------------------- |
| requires | Dependencies |
| method | Codes to be executed |
```javascript
// define('A', () => 'A');
use(['A'], function(A) {
console.log(A + 'B'); // -> 'AB'
});
```
## utf8
UTF-8 encoding and decoding.
Type Definition
### encode
Turn any UTF-8 decoded string into UTF-8 encoded string.
| Name | Desc |
| ------ | ---------------- |
| str | String to encode |
| return | Encoded string |
### decode
Turn any UTF-8 encoded string into UTF-8 decoded string.
| Name | Desc |
| ---------- | ---------------------- |
| str | String to decode |
| safe=false | Suppress error if true |
| return | Decoded string |
```javascript
utf8.encode('\uD800\uDC00'); // -> '\xF0\x90\x80\x80'
utf8.decode('\xF0\x90\x80\x80'); // -> '\uD800\uDC00'
```
## uuid
RFC4122 version 4 compliant uuid generator.
Type Definition
function uuid(): string;
Check [RFC4122 4.4](http://www.ietf.org/rfc/rfc4122.txt) for reference.
```javascript
uuid(); // -> '53ce0497-6554-49e9-8d79-347406d2a88b'
```
## values
Create an array of the own enumerable property values of object.
Type Definition
function values(obj: any): any[];
| Name | Desc |
| ------ | ------------------------ |
| obj | Object to query |
| return | Array of property values |
```javascript
values({ one: 1, two: 2 }); // -> [1, 2]
```
## viewportScale
Get viewport scale.
Type Definition
function viewportScale(): number;
```javascript
viewportScale(); // -> 3
```
## vlq
Variable-length quantity encoding and decoding.
Type Definition
### encode
Encode numbers into vlq string.
| Name | Desc |
| ------ | ---------------- |
| number | Number to encode |
| return | Encoded string |
### decode
Decode vlq string into numbers.
| Name | Desc |
| ------ | ---------------- |
| string | String to decode |
| return | Decoded numbers |
```javascript
vlq.encode(123); // -> '2H'
vlq.encode([123, 456, 789]); // -> '2HwcqxB'
vlq.decode('2H'); // -> [123]
vlq.decode('2HwcqxB'); // -> [123, 456, 789]
```
## waitUntil
Wait until function returns a truthy value.
Type Definition
function waitUntil(
condition: types.AnyFn,
timeout?: number,
interval?: number
): Promise<any>;
| Name | Desc |
| ------------ | ------------------ |
| condition | Condition function |
| timeout=0 | Timeout |
| interval=250 | Wait interval |
```javascript
let a = 5;
setTimeout(() => (a = 10), 500);
waitUntil(() => a === 10).then(() => {
console.log(a); // -> 10
});
```
## waterfall
Run an array of functions in series.
Type Definition
function waterfall(tasks: types.AnyFn[], cb?: types.AnyFn): void;
| Name | Desc |
| ----- | ----------------------- |
| tasks | Array of functions |
| cb | Callback once completed |
```javascript
waterfall(
[
function(cb) {
cb(null, 'one');
},
function(arg1, cb) {
// arg1 -> 'one'
cb(null, 'done');
}
],
function(err, result) {
// result -> 'done'
}
);
```
## wordWrap
Wrap a string to a given length.
Type Definition
function wordWrap(txt: string, width: number): string;
| Name | Desc |
| ------ | ------------------------------ |
| txt | Text to wrap |
| width | Text width |
| return | String wrapped at given length |
```javascript
wordWrap('Zso is a utility library.', 10);
// -> 'Zso is \na utility \nlibrary.'
```
## wordsToBytes
Convert 32-bit words to bytes.
Type Definition
function wordsToBytes(words: number[]): number[];
| Name | Desc |
| ------ | ---------- |
| words | Word array |
| return | Byte array |
```javascript
wordsToBytes([0x12345678]); // -> [0x12, 0x34, 0x56, 0x78]
```
## workerize
Move a stand-alone function to a worker thread.
Type Definition
function workerize(fn: types.AnyFn): types.AnyFn;
| Name | Desc |
| ------ | ------------------- |
| fn | Function to turn |
| return | Workerized Function |
```javascript
const worker = workerize(function(a, b) {
return a + b;
});
worker(1, 2).then(function(value) {
console.log(value); // -> 3
});
```
## wrap
Wrap the function inside a wrapper function, passing it as the first argument.
Type Definition
function wrap(
fn: types.AnyFn,
wrapper: types.AnyFn
): types.AnyFn;
| Name | Desc |
| ------- | ---------------- |
| fn | Function to wrap |
| wrapper | Wrapper function |
| return | New function |
```javascript
const p = wrap(escape, function(fn, text) {
return '
' + fn(text) + '
';
});
p('You & Me'); // -> '
You & Me
'
```
## wx
Promised version of mini program wx object.
Type Definition
const wx: any;
```javascript
wx.getStorage('test').then(res => {
console.log(res.data);
});
```
## xpath
Select elements using xpath, IE is not supported.
Type Definition
function xpath(xpath: string): HTMLElement[];
| Name | Desc |
| ------ | --------------- |
| xpath | Xpath |
| return | Target elements |
```javascript
xpath('//html/body'); // -> [body]
```
## zip
Merge together the values of each of the arrays with the values at the corresponding position.
Type Definition
function zip(...arr: Array<any[]>): Array<any[]>;
| Name | Desc |
| ------ | ----------------------------- |
| arr | Arrays to process |
| return | New array of grouped elements |
```javascript
zip(['a', 'b'], [1, 2], [true, false]); // -> [['a', 1, true], ['b', 2, false]]
```