Licia

$

jQuery like style dom manipulator.

Type Definition

typescript

namespace $ {
    class $ extends Select {
        find(selector: string): $;
        each(fn: types.AnyFn): $;
        offset(): $offset.IOffset;
        hide(): $;
        show(): $;
        first(): $;
        last(): $;
        get(index: number): Element;
        eq(index: number): $;
        on(event: string, selector: string, handler: types.AnyFn): $;
        on(event: string, handler: types.AnyFn): $;
        off(event: string, selector: string, handler: types.AnyFn): $;
        off(event: string, handler: types.AnyFn): $;
        html(): string;
        html(value: string): $;
        text(): string;
        text(value: string): $;
        val(): string;
        val(value: string): $;
        css(name: string): string;
        css(name: string, value: string): $;
        css(properties: types.PlainObj<string | number>): $;
        attr(name: string): string;
        attr(name: string, value: string): $;
        attr(attributes: types.PlainObj<string>): $;
        data(name: string): string;
        data(name: string, value: string): $;
        data(attributes: types.PlainObj<string>): $;
        rmAttr(name: string): $;
        remove(): $;
        addClass(name: string | string[]): $;
        rmClass(name: string): $;
        toggleClass(name: string): $;
        hasClass(name: string): boolean;
        parent(): $;
        append(content: string | Element): $;
        prepend(content: string | Element): $;
        before(content: string | Element): $;
        after(content: string | Element): $;
    }
}
declare function $(selector: string | Element | Document): $.$;

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

source test1.0.0

Element attribute manipulation.

Type Definition

typescript

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

source test1.0.0

Element class manipulations.

Type Definition

typescript

const $class: {
    add(element: $safeEls.El, name: string | string[]): void;
    has(element: $safeEls.El, name: string): boolean;
    toggle(element: $safeEls.El, name: string): void;
    remove(element: $safeEls.El, name: string): void;
};

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

source test1.0.0

Element css manipulation.

Type Definition

typescript

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

source test1.0.0

Wrapper of $attr, adds data- prefix to keys.

Type Definition

typescript

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

source test1.0.0

bind events to certain dom elements.

Type Definition

typescript

const $event: {
    on(
        element: $safeEls.El,
        event: string,
        selector: string,
        handler: types.AnyFn
    ): void;
    on(element: $safeEls.El, event: string, handler: types.AnyFn): void;
    off(
        element: $safeEls.El,
        event: string,
        selector: string,
        handler: types.AnyFn
    ): void;
    off(element: $safeEls.El, event: string, handler: types.AnyFn): void;
};

javascript

function clickHandler() {
    // Do something...
}
$event.on('#test', 'click', clickHandler);
$event.off('#test', 'click', clickHandler);

$insert

source test1.0.0

Insert html on different position.

Type Definition

typescript

namespace $insert {
    type IInsert = (element: $safeEls.El, content: string | Element) => void;
}
const $insert: {
    before: $insert.IInsert;
    after: $insert.IInsert;
    append: $insert.IInsert;
    prepend: $insert.IInsert;
};

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

// <div id="test"><div class="mark"></div></div>
$insert.before('#test', '<div>licia</div>');
// -> <div>licia</div><div id="test"><div class="mark"></div></div>
$insert.after('#test', '<div>licia</div>');
// -> <div id="test"><div class="mark"></div></div><div>licia</div>
$insert.prepend('#test', '<div>licia</div>');
// -> <div id="test"><div>licia</div><div class="mark"></div></div>
$insert.append('#test', '<div>licia</div>');
// -> <div id="test"><div class="mark"></div><div>licia</div></div>

$offset

source test1.0.0

Get the position of the element in document.

Type Definition

typescript

namespace $offset {
    interface IOffset {
        left: number;
        top: number;
        width: number;
        height: number;
    }
}
function $offset(element: $safeEls.El): $offset.IOffset;

Name	Desc
element	Elements to get offset
return	Element position

javascript

$offset('#test'); // -> {left: 0, top: 0, width: 0, height: 0}

$property

source test1.0.0

Element property html, text, val getter and setter.

Type Definition

typescript

namespace $property {
    interface IProperty {
        (element: $safeEls.El, value: string): void;
        (element: $safeEls.El): string;
    }
}
const $property: {
    html: $property.IProperty;
    val: $property.IProperty;
    text: $property.IProperty;
};

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', 'licia');
$property.html('#test'); // -> licia

$remove

source test1.0.0

Remove the set of matched elements from the DOM.

Type Definition

typescript

function $remove(element: $safeEls.El);

Name	Desc
element	Elements to delete

javascript

$remove('#test');

$safeEls

source test1.0.0

Convert value into an array, if it's a string, do querySelector.

Type Definition

typescript

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

source test1.0.0

Show elements.

Type Definition

typescript

function $show(element: $safeEls.El): void;

Name	Desc
element	Elements to show

javascript

$show('#test');

Benchmark

source test1.30.0

JavaScript Benchmark.

Type Definition

typescript

namespace Benchmark {
    interface IOptions {
        minTime?: number;
        maxTime?: number;
        minSamples?: number;
        delay?: number;
        name?: string;
    }
    interface IResult {
        name: string;
        mean: number;
        variance: number;
        deviation: number;
        sem: number;
        moe: number;
        rme: number;
        hz: number;
        sample: number[];
    }
}
class Benchmark {
    constructor(fn: types.AnyFn, options?: Benchmark.IOptions);
    run(): Promise<Benchmark.IResult>;
    static all(
        benches: Array<types.AnyFn | Benchmark>,
        options?: Benchmark.IOptions
    ): Promise<Benchmark.IResult[]>;
}

constructor

Name	Desc
fn	Code for speed testing
options	Benchmark options

Available options:

Name	Desc
minTime=50	Time needed to reduce uncertainty
maxTime=5000	Maximum time for running benchmark
minSamples=5	Minimum sample size
delay=5	Delay between test cycles
name	Benchmark name

run

Run benchmark, returns a promise.

all

[static] Run some benchmarks.

javascript

const benchmark = new Benchmark(
    function test() {
        !!'Hello World!'.match(/o/);
    },
    {
        maxTime: 1500
    }
);
benchmark.run().then(result => {
    console.log(String(result));
});
Benchmark.all([
    function regExp() {
        /o/.test('Hello World!');
    },
    function indexOf() {
        'Hello World!'.indexOf('o') > -1;
    },
    function match() {
        !!'Hello World!'.match(/o/);
    }
]).then(results => {
    console.log(String(results));
});

Blob

source test1.0.0

Use Blob when available, otherwise BlobBuilder.

constructor

Name	Desc
parts	Blob parts
options	Options

javascript

const blob = new Blob([]);

BloomFilter

source test1.10.0

Bloom filter implementation.

Type Definition

typescript

class BloomFilter {
    constructor(size?: number, k?: number);
    add(val: string): void;
    test(val: string): boolean;
}

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

source test1.9.0

Modify object props without caring about letter case.

Type Definition

typescript

class Caseless {
    constructor(obj: any);
    getKey(key: string): string | void;
    set(key: string, val: any): void;
    get(key: string): any;
    remove(key: string): void;
    has(key: string): boolean;
}

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

Channel

source test1.42.0

Interconnectable Message channel.

Type Definition

typescript

class Channel extends Emitter {
    send(msg: any): void;
    connect(channel: Channel): void;
    disconnect(channel: Channel): void;
    isConnected(channel: Channel): boolean;
    destroy(): void;
}

send

Send a message to all connected channels.

Name	Desc
msg	Message to send

connect

Connect to another channel.

Name	Desc
channel	Channel to connect

disconnect

Disconnect from another channel.

Name	Desc
channel	Channel to disconnect

isConnected

Check if a channel is connected to another channel.

Name	Desc
channel	Channel to check
return	Whether it's connected

destroy

Destroy the channel, disconnect from all connected channels.

javascript

const channelA = new Channel();
const channelB = new Channel();
channelA.connect(channelB);
channelB.on('message', msg => {
    console.log(msg); // -> 'hello'
});
channelA.send('hello');
channelA.on('message', msg => {
    console.log(msg); // -> 'world'
});
channelB.send('world');
channelA.isConnected(channelB); // -> true
channelB.isConnected(channelA); // -> true

Class

source test demo1.0.0

Create JavaScript class.

Type Definition

typescript

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

source test1.0.0

Color converter.

Type Definition

typescript

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

source test1.17.0

Object delegation.

Type Definition

typescript

class Delegator {
    constructor(host: object, target: object | string);
    method(name: string, target?: string): Delegator;
    getter(name: string, target?: string): Delegator;
    setter(name: string, target?: string): Delegator;
    access(name: string, target?: string): Delegator;
}

constructor

Name	Desc
host	Host object
target	Delegation target

method

Allow method to be accessed on the host object.

Name	Desc
name	Host method name
target=name	Target method name

getter

Create a getter.

setter

Create a setter.

access

Create a accessor, same as calling both setter and getter.

javascript

const host = {
    target: {
        a() {
            return 'a';
        },
        b: 'b',
        c: 'c',
        d: 'd',
        e() {
            return 'e';
        }
    }
};
const delegator = new Delegator(host, 'target');
delegator
    .method('a')
    .getter('b')
    .setter('c')
    .access('d');
host.a(); // -> 'a'
host.b; // -> 'b'
host.c = 5;
host.target.c; // -> 5
host.d; // -> 'd'
host.d = 5;
host.d; // -> 5

Dispatcher

source test1.0.0

Flux dispatcher.

Type Definition

typescript

class Dispatcher {
    dispatch(payload: any);
    register(cb: types.AnyFn): void;
    waitFor(ids: string[]): void;
    unregister(id: string): void;
    isDispatching(): boolean;
}

Related docs

javascript

const dispatcher = new Dispatcher();

dispatcher.register(function(payload) {
    switch (
        payload.actionType
        // Do something
    ) {
    }
});

dispatcher.dispatch({
    actionType: 'action'
});

Emitter

source test1.0.0

Event emitter class which provides observer pattern.

Type Definition

typescript

class Emitter {
    on(event: string, listener: types.AnyFn): Emitter;
    off(event: string, listener: types.AnyFn): Emitter;
    once(event: string, listener: types.AnyFn): Emitter;
    emit(event: string, ...args: any[]): Emitter;
    removeAllListeners(event?: string): Emitter;
    static mixin(obj: any): any;
}

on

Bind event.

off

Unbind event.

once

Bind event that trigger once.

Name	Desc
event	Event name
listener	Event listener

emit

Emit event.

Name	Desc
event	Event name
...args	Arguments passed to listener

removeAllListeners

Remove all listeners.

Name	Desc
event	Event name

mixin

[static] Mixin object class methods.

Name	Desc
obj	Object to mixin

javascript

const event = new Emitter();
event.on('test', function(name) {
    console.log(name);
});
event.emit('test', 'licia'); // Logs out 'licia'.
Emitter.mixin({});

Enum

source test1.0.0

Enum type implementation.

Type Definition

typescript

class Enum {
    size: number;
    constructor(map: string[] | { [member: string]: any });
    [key: string]: any;
}

constructor

Name	Desc
arr	Array of strings

Name	Desc
obj	Pairs of key and value

javascript

const importance = new Enum([
    'NONE',
    'TRIVIAL',
    'REGULAR',
    'IMPORTANT',
    'CRITICAL'
]);
const val = 1;
if (val === importance.CRITICAL) {
    // Do something.
}

FileBlobStore

source test1.32.0

Binary file storage.

Type Definition

typescript

class FileBlobStore extends Emitter {
    constructor(path: string, data?: types.PlainObj<Buffer>);
    set(key: string, buf: Buffer): void;
    set(values: types.PlainObj<Buffer>): void;
    get(key: string): Buffer | void;
    get(keys: string[]): types.PlainObj<Buffer>;
    remove(key: string): void;
    remove(keys: string[]): void;
    clear(): void;
    each(fn: (val: Buffer, key: string) => void): void;
    save(): void;
}

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('licia'));
process.on('exit', () => store.save());

FileStore

source test1.32.0

File storage.

Type Definition

typescript

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', 'licia');

HashTable

source test1.13.0

Hash table implementation.

Type Definition

typescript

class HashTable {
    constructor(size?: number);
    set(key: string, val: any): void;
    get(key: string): any;
    has(key: string): boolean;
    delete(key: string): void;
}

constructor

Name	Desc
size=32	Bucket size

set

Set value.

Name	Desc
key	Value key
val	Value to set

get

Get value.

Name	Desc
key	Value key
return	Value of given key

has

Check if has value.

Name	Desc
key	Value key
return	True if value exists

delete

Delete value.

javascript

const hashTable = new HashTable(128);
hashTable.set('name', 'redhoodsu');
hashTable.get('name'); // -> 'redhoodsu'
hashTable.has('name'); // -> true
hashTable.delete('name');
hashTable.has('name'); // -> false

Heap

source test1.11.0

Heap implementation.

Type Definition

typescript

class Heap {
    size: number;
    constructor(cmp?: types.AnyFn);
    clear(): void;
    add(item: any): number;
    poll(): any;
    peek(): any;
}

size

Heap size.

constructor

Name	Desc
cmp	Comparator

clear

Clear the heap.

add

Add an item to the heap.

Name	Desc
item	Item to add
return	Current size

poll

Retrieve and remove the root item of the heap.

peek

Same as poll, but does not remove the item.

javascript

const heap = new Heap(function(a, b) {
    return b - a;
});
heap.add(2);
heap.add(1);
heap.add(4);
heap.add(5);
heap.poll(); // -> 5
console.log(heap.size); // -> 4

HeapSnapshot

source test1.31.0

V8 heap snapshot manipulator.

Type Definition

typescript

class HeapSnapshot {
    nodes: LinkedList;
    edges: LinkedList;
    constructor(profile: any);
}

constructor

Name	Desc
profile	Profile to parse

nodes

Parsed nodes.

edges

Parsed edges.

javascript

const fs = require('fs');
const data = fs.readFileSync('path/to/heapsnapshot', 'utf8');
const heapSnapshot = new HeapSnapshot(data);
let totalSize = 0;
heapSnapshot.nodes.forEach(node => (totalSize += node.selfSize));
console.log(totalSize);

I18n

source test1.23.0

Simple internationalization library.

Type Definition

typescript

class I18n {
    constructor(locale: string, langs: types.PlainObj<any>);
    set(locale: string, lang: types.PlainObj<any>): void;
    t(path: string | string[], data?: types.PlainObj<any>): string;
    locale(locale: string): void;
}

constructor

Name	Desc
locale	Locale code
langs	Language data

set

Add language or append extra keys to existing language.

Name	Desc
locale	Locale code
lang	Language data

locale

Set default locale.

Name	Desc
locale	Locale code

t

Get translation text.

Name	Desc
path	Path of translation to get
data	Data to pass in
return	Translation text

javascript

const i18n = new I18n('en', {
    en: {
        welcome: 'Hello, {{name}}!',
        curTime(data) {
            return 'Current time is ' + data.time;
        }
    },
    cn: {
        welcome: '你好，{{name}}！'
    }
});
i18n.set('cn', {
    curTime(data) {
        return '当前时间是 ' + data.time;
    }
});
i18n.t('welcome', { name: 'licia' }); // -> 'Hello, licia!'
i18n.locale('cn');
i18n.t('curTime', { time: '5:47 pm' }); // -> '当前时间是 5:47 pm'

JsonTransformer

source test1.0.0

Json to json transformer.

Type Definition

typescript

class JsonTransformer {
    constructor(data: any);
    set(key: string, val: any): JsonTransformer;
    get(key?: string): any;
    map(from: string, to: string, fn: types.AnyFn): JsonTransformer;
    map(from: string, fn: types.AnyFn): JsonTransformer;
    filter(from: string, to: string, fn: types.AnyFn): JsonTransformer;
    filter(from: string, fn: types.AnyFn): JsonTransformer;
    remove(keys: string | string[]): JsonTransformer;
    compute(
        from: string | string[],
        to: string,
        fn: types.AnyFn
    ): JsonTransformer;
    compute(from: string, fn: types.AnyFn): JsonTransformer;
    toString(): string;
}

constructor

Name	Desc
data={}	Json object to manipulate

set

Set object value.

Name	Desc
key	Object key
val	Value to set

If key is not given, the whole source object is replaced by val.

get

Get object value.

Name	Desc
key	Object key
return	Specified value or whole object

remove

Remove object value.

Name	Desc
key	Object keys to remove

map

Shortcut for array map.

Name	Desc
from	From object path
to	Target object path
fn	Function invoked per iteration

filter

Shortcut for array filter.

compute

Compute value from several object values.

Name	Desc
from	Source values
to	Target object path
fn	Function to compute target value

javascript

const data = new JsonTransformer({
    books: [
        {
            title: 'Book 1',
            price: 5
        },
        {
            title: 'Book 2',
            price: 10
        }
    ],
    author: {
        lastname: 'Su',
        firstname: 'RedHood'
    }
});
data.filter('books', function(book) {
    return book.price > 5;
});
data.compute('author', function(author) {
    return author.firstname + author.lastname;
});
data.set('count', data.get('books').length);
data.get(); // -> {books: [{title: 'Book 2', price: 10}], author: 'RedHoodSu', count: 1}

LinkedList

source test1.0.0

Doubly-linked list implementation.

Type Definition

typescript

namespace LinkedList {
    class Node {
        value: any;
        prev: Node | null;
        next: Node | null;
    }
}
class LinkedList {
    size: number;
    head: LinkedList.Node;
    tail: LinkedList.Node;
    push(val: any): number;
    pop(): any;
    unshift(val: any): number;
    shift(): any;
    find(fn: types.AnyFn): LinkedList.Node | void;
    delNode(node: LinkedList.Node): void;
    forEach(iterator: types.AnyFn, ctx?: any);
    toArr(): any[];
}

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

source test1.0.0

LocalStorage wrapper.

Type Definition

typescript

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('licia');
store.set('name', 'licia');

Logger

source test demo1.0.0

Simple logger with level filter.

Type Definition

typescript

class Logger extends Emitter {
    name: string;
    formatter(type: string, argList: any[]): any[];
    constructor(name: string, level?: string | number);
    setLevel(level: string | number): Logger;
    getLevel(): number;
    trace(...args: any[]): Logger;
    debug(...args: any[]): Logger;
    info(...args: any[]): Logger;
    warn(...args: any[]): Logger;
    error(...args: any[]): Logger;
    static level: Enum;
}

constructor

Name	Desc
name	Logger name
level=DEBUG	Logger level

setLevel

Set level.

Name	Desc
level	Logger level

getLevel

Get current level.

trace, debug, info, warn, error

Logging methods.

Log Levels

TRACE, DEBUG, INFO, WARN, ERROR and SILENT.

javascript

const logger = new Logger('licia', Logger.level.ERROR);
logger.trace('test');

// Format output.
logger.formatter = function(type, argList) {
    argList.push(new Date().getTime());

    return argList;
};

logger.on('all', function(type, argList) {
    // It's not affected by log level.
});

logger.on('debug', function(argList) {
    // Affected by log level.
});

Lru

source test1.4.5

Simple LRU cache.

Type Definition

typescript

class Lru {
    constructor(max: number);
    has(key: string): boolean;
    remove(key: string): void;
    get(key: string): any;
    set(key: string, val: any): void;
    clear(): void;
}

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', 'licia');
cache.get('test'); // -> 'licia'

MediaQuery

source test demo1.5.2

CSS media query listener.

Type Definition

typescript

class MediaQuery extends Emitter {
    constructor(query: string);
    setQuery(query: string): void;
    isMatch(): boolean;
}

Extend from Emitter.

constructor

Name	Desc
query	Media query

setQuery

Update 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

source test1.0.0

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

source test1.11.0

Priority queue implementation.

Type Definition

typescript

class PriorityQueue {
    size: number;
    constructor(cmp?: types.AnyFn);
    clear(): void;
    enqueue(item: any): number;
    dequeue(): any;
    peek(): any;
}

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

source test demo1.0.0

Lightweight Promise implementation.

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

source test1.0.0

Like es6 Map, without iterators.

Type Definition

typescript

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

source test1.0.0

Queue data structure.

Type Definition

typescript

class Queue {
    size: number;
    clear(): void;
    enqueue(item: any): number;
    dequeue(): any;
    peek(): any;
    forEach(iterator: types.AnyFn, context?: any): void;
    toArr(): any[];
}

size

Queue size.

clear

Clear the queue.

enqueue

Add an item to the queue.

Name	Desc
item	Item to enqueue
return	Current size

dequeue

Remove the first item of the queue.

peek

Get the first item without removing it.

forEach

Iterate over the queue.

Name	Desc
iterator	Function invoked iteration
ctx	Function context

toArr

Convert queue to a JavaScript array.

javascript

const queue = new Queue();

console.log(queue.size); // -> 0
queue.enqueue(2);
queue.enqueue(3);
queue.dequeue(); // -> 2
console.log(queue.size); // -> 1
queue.peek(); // -> 3
console.log(queue.size); // -> 1

QuickLru

source test benchmark1.4.5

LRU implementation without linked list.

Type Definition

typescript

class QuickLru {
    constructor(max: number);
    has(key: string): boolean;
    remove(key: string): void;
    get(key: string): any;
    set(key: string, val: any): void;
    clear(): void;
}

Inspired by the hashlru algorithm.

The api is the same as Lru module.

javascript

const cache = new QuickLru(50);
cache.set('test', 'licia');
cache.get('test'); // -> 'licia'

Readiness

source test1.32.0

Readiness manager.

Type Definition

typescript

class Readiness {
    signal(tasks: string | string[]): void;
    isReady(tasks: string | string[]): boolean;
    ready(tasks: string | string[], fn?: types.AnyFn): Promise<void>;
}

signal

Signal task is ready.

Name	Desc
tasks	Ready tasks

ready

Name	Desc
tasks	Tasks to listen
fn	Callback to trigger if tasks are ready
return	Promise that will be resolved when ready

isReady

Check if tasks are ready.

Name	Desc
tasks	Tasks to check
return	True if all tasks are ready

javascript

const readiness = new Readiness();
readiness.ready('serverCreated', function() {
    // Do something.
});
readiness.signal('serverCreated');
readiness.isReady('serverCreated'); // -> true

ReduceStore

source test1.0.0

Simplified redux like state container.

Type Definition

typescript

class ReduceStore {
    constructor(reducer: types.AnyFn, initialState: any);
    subscribe(listener: types.AnyFn): types.AnyFn;
    dispatch(action: any): any;
    getState(): any;
}

constructor

Name	Desc
reducer	Function returns next state
initialState	Initial state

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

source test demo1.29.0

Detect if element's size has changed.

Type Definition

typescript

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

source test1.0.0

Simple wrapper of querySelectorAll to make dom selection easier.

Type Definition

typescript

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

source test1.20.0

Limit simultaneous access to a resource.

Type Definition

typescript

class Semaphore {
    constructor(counter?: number);
    wait(fn: () => void): void;
    signal(): void;
}

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

source test1.0.0

SessionStorage wrapper.

Type Definition

typescript

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('licia');
store.set('name', 'licia');

SingleEmitter

source test1.29.0

Event emitter with single event type.

Type Definition

typescript

class SingleEmitter {
    addListener(listener: types.AnyFn): void;
    rmListener(listener: types.AnyFn): void;
    emit(...args: any[]): void;
    rmAllListeners(): void;
    static mixin(obj: any): void;
}

addListener

Add listener.

rmListener

Remove listener.

Name	Desc
listener	Event listener

rmAllListeners

Remove all listeners.

emit

Call listeners.

Name	Desc
...args	Arguments passed to listener

mixin

[static] Mixin object class methods.

Name	Desc
obj	Object to mixin

javascript

const event = new SingleEmitter();
event.addListener(function(name) {
    console.log(name);
});
event.emit('licia'); // Logs out 'licia'.

Socket

source test1.22.0

Tiny WebSocket wrapper.

Type Definition

typescript

class Socket extends Emitter {
    constructor(
        url: string,
        options?: {
            protocols?: string | string[];
            reconnect?: boolean;
        }
    );
    send(message: any): void;
    close(code?: number, reason?: string): void;
    connect(): void;
}

Extend from Emitter.

constructor

Name	Desc
url	Url to connect
options	Connect options

Available options:

Name	Desc
protocols	Protocol string
reconnect=true	Try to reconnect if possible

send

Send message.

Name	Desc
message	Message to send

close

Close WebSocket.

Name	Desc
code	Status code
reason	Reason of closing

connect

Connect WebSocket, called when initialized.

javascript

const ws = new Socket('ws://localhost:8001');
ws.on('open', e => ws.send('Hello'));

Stack

source test1.0.0

Stack data structure.

Type Definition

typescript

class Stack {
    size: number;
    clear(): void;
    push(item: any): number;
    pop(): any;
    peek(): any;
    forEach(iterator: types.AnyFn, context?: any): void;
    toArr(): any[];
}

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

source test1.0.0

Simple state machine.

Type Definition

typescript

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

source test1.0.0

Memory storage.

Type Definition

typescript

class Store extends Emitter {
    constructor(data?: {});
    set(key: string, val: any): void;
    set(values: {}): void;
    get(key: string): any;
    get(keys: string[]): {};
    remove(key: string): void;
    remove(keys: string[]): void;
    clear(): void;
    each(fn: (...args: any[]) => void): void;
}

Extend from Emitter.

constructor

Name	Desc
data	Initial data

set

Set value.

Name	Desc
key	Value key
val	Value to set

Set values.

Name	Desc
values	Key value pairs

This emit a change event whenever is called.

get

Get value.

Name	Desc
key	Value key
return	Value of given key

Get values.

Name	Desc
keys	Array of keys
return	Key value pairs

remove

Remove value.

Name	Desc
key	Key to remove

clear

Clear all data.

each

Iterate over values.

Name	Desc
fn	Function invoked per iteration

javascript

const store = new Store('test');
store.set('user', { name: 'licia' });
store.get('user').name; // -> 'licia'
store.clear();
store.each(function(val, key) {
    // Do something.
});
store.on('change', function(key, newVal, oldVal) {
    // It triggers whenever set is called.
});

Trace

source test1.33.0

Parse, manipulate and generate chrome tracing data.

Type Definition

typescript

namespace Trace {
    interface IEvent {
        name: string;
        cat: string;
        ph: string;
        ts: number;
        pid: number;
        tid: number;
        args: any;
        [key: string]: any;
    }
    class Process {
        constructor(id);
        id(): string;
        name(): string;
        addEvent(IEvent): void;
        rmEvent(IEvent): void;
        getThread(id: number): Thread;
        rmThread(id: number): void;
        threads(): Thread[];
        toJSON(): IEvent[];
    }
    class Thread {
        constructor(id, pid);
        id(): string;
        name(): string;
        addEvent(IEvent): void;
        rmEvent(IEvent): void;
        events(): IEvent[];
        toJSON(): IEvent[];
    }
}
class Trace {
    constructor(events: Trace.IEvent[]);
    addEvent(event: Trace.IEvent);
    rmEvent(event: Trace.IEvent);
    getProcess(id: number): Trace.Process;
    rmProcess(id: number): void;
    processes(): Trace.Process[];
    toJSON(): Trace.IEvent[];
}

javascript

const fs = require('fs');
const data = fs.readFileSync('path/to/trace', 'utf8');
const trace = new Trace(JSON.parse(data));
trace.rmProcess(627);
fs.writeFileSync(
    'path/to/trace',
    JSON.stringify(trace.toJSON()),
    'utf8',
    function() {}
);

Tracing

source test1.33.0

Easily create chrome tracing data.

Type Definition

typescript

class Tracing {
    constructor(options?: {
        pid?: number;
        tid?: number;
        processName?: string;
        threadName?: string;
    });
    start(cat?: string): void;
    stop(): Trace.IEvent[];
    metadata(name: string, args: any): void;
    begin(cat: string, name: string, args?: any): void;
    end(args?: any): void;
    asyncBegin(cat: string, name: string, id?: string, args?: any): string;
    asyncEnd(id: string, args?: any): void;
    instant(
        cat: string,
        name: string,
        scope?: 'g' | 'p' | 't',
        args?: any
    ): void;
    id(): string;
}

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

source test1.25.0

Trie data structure.

Type Definition

typescript

class Trie {
    add(word: string): void;
    remove(word: string): void;
    has(word: string): boolean;
    words(prefix: string): string[];
    clear(): void;
}

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

source test demo1.0.0

Tween engine for JavaScript animations.

Type Definition

typescript

class Tween extends Emitter {
    constructor(target: any);
    to(props: any, duration?: number, ease?: string | Function): Tween;
    progress(): number;
    progress(progress: number): Tween;
    play(): Tween;
    pause(): Tween;
    paused(): boolean;
}

Extend from Emitter.

constructor

Name	Desc
obj	Values to tween

to

Name	Desc
destination	Final properties
duration	Tween duration
ease	Easing function

play

Begin playing forward.

pause

Pause the animation.

paused

Get animation paused state.

progress

Update or get animation progress.

Name	Desc
progress	Number between 0 and 1

javascript

const pos = { x: 0, y: 0 };

const tween = new Tween(pos);
tween
    .on('update', function(target) {
        console.log(target.x, target.y);
    })
    .on('end', function(target) {
        console.log(target.x, target.y); // -> 100, 100
    });
tween.to({ x: 100, y: 100 }, 1000, 'inElastic').play();

Url

source test1.0.0

Simple url manipulator.

Type Definition

typescript

namespace Url {
    interface IUrl {
        protocol: string;
        auth: string;
        hostname: string;
        hash: string;
        query: any;
        port: string;
        pathname: string;
        slashes: boolean;
    }
}
class Url {
    protocol: string;
    auth: string;
    hostname: string;
    hash: string;
    query: any;
    port: string;
    pathname: string;
    slashes: boolean;
    constructor(url?: string);
    setQuery(name: string, val: string | number): Url;
    setQuery(query: types.PlainObj<string | number>): Url;
    rmQuery(name: string | string[]): Url;
    toString(): string;
    static parse(url: string): Url.IUrl;
    static stringify(object: Url.IUrl): string;
}

constructor

Name	Desc
url=location	Url string

setQuery

Set query value.

Name	Desc
name	Query name
val	Query value
return	this

Name	Desc
query	query object
return	this

rmQuery

Remove query value.

Name	Desc
name	Query name
return	this

parse

[static] Parse url into an object.

Name	Desc
url	Url string
return	Url object

stringify

[static] Stringify url object into a string.

Name	Desc
url	Url object
return	Url string

An url object contains the following properties:

Name	Desc
protocol	The protocol scheme of the URL (e.g. http:)
slashes	A boolean which indicates whether the protocol is followed by two forward slashes (//)
auth	Authentication information portion (e.g. username:password)
hostname	Host name without port number
port	Optional port number
pathname	URL path
query	Parsed object containing query string
hash	The "fragment" portion of the URL including the pound-sign (#)

javascript

const url = new Url('http://example.com:8080?eruda=true');
console.log(url.port); // -> '8080'
url.query.foo = 'bar';
url.rmQuery('eruda');
url.toString(); // -> 'http://example.com:8080/?foo=bar'

Validator

source test1.0.0

Object values validation.

Type Definition

typescript

class Validator {
    constructor(options: types.PlainObj<any>);
    validate(object: any): string | boolean;
    static plugins: any;
    static addPlugin(name: string, plugin: types.AnyFn): void;
}

constructor

Name	Desc
options	Validation configuration

validate

Validate object.

Name	Desc
obj	Object to validate
return	Validation result, true means ok

addPlugin

[static] Add plugin.

Name	Desc
name	Plugin name
plugin	Validation handler

Default Plugins

Required, number, boolean, string and regexp.

javascript

Validator.addPlugin('custom', function(val, key, config) {
    if (typeof val === 'string' && val.length === 5) return true;

    return key + ' should be a string with length 5';
});
const validator = new Validator({
    test: {
        required: true,
        custom: true
    }
});
validator.validate({}); // -> 'test is required'
validator.validate({ test: 1 }); // -> 'test should be a string with length 5';
validator.validate({ test: 'licia' }); // -> true

Wrr

source test1.21.0

Weighted Round Robin implementation.

Type Definition

typescript

class Wrr {
    size: number;
    set(val: any, weight: number): void;
    get(val: any): number | void;
    remove(val: any): void;
    clear(): void;
    next(): any;
}

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

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

source test1.0.0

Calculate the set of unique abbreviations for a given set of strings.

Type Definition

typescript

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

source test1.0.0

Create a function that invokes once it's called n or more times.

Type Definition

typescript

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

source test1.0.0

Perform an asynchronous HTTP request.

Type Definition

typescript

namespace ajax {
    function get(
        url: string,
        data: string | {},
        success: types.AnyFn,
        dataType?: string
    ): XMLHttpRequest;
    function get(
        url: string,
        success: types.AnyFn,
        dataType?: string
    ): XMLHttpRequest;
    function post(
        url: string,
        data: string | {},
        success: types.AnyFn,
        dataType?: string
    ): XMLHttpRequest;
    function post(
        url: string,
        success: types.AnyFn,
        dataType?: string
    ): XMLHttpRequest;
}
function ajax(options: {
    type?: string;
    url: string;
    data?: string | {};
    dataType?: string;
    contentType?: string;
    success?: types.AnyFn;
    error?: types.AnyFn;
    complete?: types.AnyFn;
    timeout?: number;
}): XMLHttpRequest;

Name	Desc
options	Ajax options

Available options:

Name	Desc
type=get	Request type
url	Request url
data	Request data
dataType=json	Response type(json, xml)
contentType=application/x-www-form-urlencoded	Request header Content-Type
success	Success callback
error	Error callback
complete	Callback after request
timeout	Request timeout

get

Shortcut for type = GET;

post

Shortcut for type = POST;

Name	Desc
url	Request url
data	Request data
success	Success callback
dataType	Response type

javascript

ajax({
    url: 'http://example.com',
    data: { test: 'true' },
    error() {},
    success(data) {
        // ...
    },
    dataType: 'json'
});

ajax.get('http://example.com', {}, function(data) {
    // ...
});

allKeys

source test1.0.0

Retrieve all the names of object's own and inherited properties.

Type Definition

typescript

namespace allKeys {
    interface IOptions {
        prototype?: boolean;
        unenumerable?: boolean;
    }
}
function allKeys(
    obj: any,
    options: { symbol: true } & allKeys.IOptions
): Array<string | Symbol>;
function allKeys(
    obj: any,
    options?: ({ symbol: false } & allKeys.IOptions) | allKeys.IOptions
): string[];

Name	Desc
obj	Object to query
options	Options
return	Array of all property names

Available options:

Name	Desc
prototype=true	Include prototype keys
unenumerable=false	Include unenumerable keys
symbol=false	Include symbol keys

Members of Object's prototype won't be retrieved.

javascript

const obj = Object.create({ zero: 0 });
obj.one = 1;
allKeys(obj); // -> ['zero', 'one']

ansiColor

source test1.4.1

Ansi colors.

Type Definition

typescript

namespace ansiColor {
    type IFn = (str: string) => string;
}
const ansiColor: {
    black: ansiColor.IFn;
    red: ansiColor.IFn;
    green: ansiColor.IFn;
    yellow: ansiColor.IFn;
    blue: ansiColor.IFn;
    magenta: ansiColor.IFn;
    cyan: ansiColor.IFn;
    white: ansiColor.IFn;
    gray: ansiColor.IFn;
    grey: ansiColor.IFn;
    bgBlack: ansiColor.IFn;
    bgRed: ansiColor.IFn;
    bgGreen: ansiColor.IFn;
    bgYellow: ansiColor.IFn;
    bgBlue: ansiColor.IFn;
    bgMagenta: ansiColor.IFn;
    bgCyan: ansiColor.IFn;
    bgWhite: ansiColor.IFn;
    blackBright: ansiColor.IFn;
    redBright: ansiColor.IFn;
    greenBright: ansiColor.IFn;
    yellowBright: ansiColor.IFn;
    blueBright: ansiColor.IFn;
    magentaBright: ansiColor.IFn;
    cyanBright: ansiColor.IFn;
    whiteBright: ansiColor.IFn;
    bgBlackBright: ansiColor.IFn;
    bgRedBright: ansiColor.IFn;
    bgGreenBright: ansiColor.IFn;
    bgYellowBright: ansiColor.IFn;
    bgBlueBright: ansiColor.IFn;
    bgMagentaBright: ansiColor.IFn;
    bgCyanBright: ansiColor.IFn;
    bgWhiteBright: ansiColor.IFn;
};

Available colors

black, red, green, yellow, blue, magenta, cyan, white, gray, grey

bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite,

blackBright, redBright, greenBright, yellowBright, blueBright, magentaBright, cyanBright, whiteBright

bgBlackBright, bgRedBright, bgGreenBright, bgYellowBright, bgBlueBright, bgMagentaBright, bgCyanBright, bgWhiteBright

javascript

ansiColor.red('Warning');

arrToMap

source test1.0.0

Make an object map using array of strings.

Type Definition

typescript

function arrToMap<T>(
    arr: string[],
    val?: T
): { [key: string]: T };

Name	Desc
arr	Array of strings
val=true	Key value
return	Object map

javascript

const needPx = arrToMap([
    'column-count',
    'columns',
    'font-weight',
    'line-weight',
    'opacity',
    'z-index',
    'zoom'
]);
const key = 'column-count';
let val = '5';
if (needPx[key]) val += 'px';
console.log(val); // -> '5px'

atob

source test1.0.0

Use Buffer to emulate atob when running in node.

Type Definition

typescript

function atob(str: string): string;

javascript

atob('SGVsbG8gV29ybGQ='); // -> 'Hello World'

average

source test1.0.0

Get average value of given numbers.

Type Definition

typescript

function average(...numbers: number[]): number;

Name	Desc
numbers	Numbers to calculate
return	Average value

javascript

average(5, 3, 1); // -> 3

base64

source test1.0.0

Basic base64 encoding and decoding.

Type Definition

typescript

const base64: {
    encode(bytes: number[]): string;
    decode(str: string): number[];
};

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

source test1.0.0

Create a function that invokes less than n times.

Type Definition

typescript

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.

binarySearch

source test1.4.0

Binary search implementation.

Type Definition

typescript

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

source test1.0.0

Create a function bound to a given object.

Type Definition

typescript

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

source test1.0.0

Use Buffer to emulate btoa when running in node.

Type Definition

typescript

function btoa(str: string): string;

javascript

btoa('Hello World'); // -> 'SGVsbG8gV29ybGQ='

bubbleSort

source test1.0.0

Bubble sort implementation.

Type Definition

typescript

function bubbleSort(arr: any[], cmp?: types.AnyFn): any[];

Name	Desc
arr	Array to sort
cmp	Comparator
return	Sorted array

javascript

bubbleSort([2, 1]); // -> [1, 2]

bytesToStr

source test1.1.0

Convert bytes to string.

Type Definition

typescript

function bytesToStr(bytes: number[], encoding?: string): string;

Name	Desc
bytes	Bytes array
encoding=utf8	Encoding of string
return	Result string

javascript

bytesToStr([108, 105, 99, 105, 97]); // -> 'licia'

bytesToWords

source test1.16.0

Convert bytes to 32-bit words.

Type Definition

typescript

function bytesToWords(bytes: number[]): number[];

Useful when using CryptoJS.

Name	Desc
bytes	Byte array
return	Word array

javascript

bytesToWords([0x12, 0x34, 0x56, 0x78]); // -> [0x12345678]

cacheRequire

source test benchmark1.32.0

Cache everything in module require to speed up app load.

Type Definition

typescript

function cacheRequire(options?: {
    dir?: string;
    requirePath?: boolean;
    code?: boolean;
    compileCache?: boolean;
}): void;

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

source test1.0.0

Convert a function that returns a Promise to a function following the error-first callback style.

Type Definition

typescript

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

source test1.0.0

Convert string to "camelCase".

Type Definition

typescript

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

source test1.0.0

Convert the first character to upper case and the remaining to lower case.

Type Definition

typescript

function capitalize(str: string): string;

Name	Desc
str	String to capitalize
return	Capitalized string

javascript

capitalize('rED'); // -> Red

castPath

source test1.0.0

Cast value into a property path array.

Type Definition

typescript

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

source test1.0.0

Center align text in a string.

Type Definition

typescript

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

source test1.35.0

Read cgroup metrics inside container.

Type Definition

typescript

const cgroup: {
    cpu: {
        stat(): {
            usage: number;
        };
        max(): number;
    };
    cpuset: {
        cpus(): {
            effective: number[];
        };
    };
    memory: {
        max(): number;
        current(): number;
    };
    version(): number;
};

javascript

cgroup.cpu.stat();

char

source test1.0.0

Return string representing a character whose Unicode code point is the given integer.

Type Definition

typescript

function char(num: number): string;

Name	Desc
num	Integer to convert
return	String representing corresponding char

javascript

char(65); // -> 'A'
char(97); // -> 'a'

chunk

source test1.0.0

Split array into groups the length of given size.

Type Definition

typescript

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

source test1.0.0

Clamp number within the inclusive lower and upper bounds.

Type Definition

typescript

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

source test1.0.0

Utility for conditionally joining class names.

Type Definition

typescript

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

source test1.27.0

Output cli help.

Type Definition

typescript

namespace cliHelp {
    interface IOption {
        name: string;
        shorthand?: string;
        desc: string;
    }
    interface ICommand {
        name: string;
        desc: string;
        usage: string | string[];
        options?: IOption[];
    }
    interface IData {
        name: string;
        usage: string | string[];
        commands: ICommand[];
    }
}
function cliHelp(data: cliHelp.IData | cliHelp.ICommand): string;

Name	Desc
data	Help data
return	Cli help

javascript

const test = {
    name: 'test',
    desc: 'Generate test files',
    usage: ['<module-name> [options]', 'lpad --browser'],
    options: [
        {
            name: 'browser',
            shorthand: 'b',
            desc: 'True if test should run in a browser'
        }
    ]
};
const data = {
    name: 'licia',
    usage: '<command> [options]',
    commands: [test]
};

cliHelp(data);
cliHelp(test);

clone

source test1.0.0

Create a shallow-copied clone of the provided plain object.

Type Definition

typescript

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

source test1.0.0

Recursively clone value.

Type Definition

typescript

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

source test1.0.0

Compare version strings.

Type Definition

typescript

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

source test1.1.0

Create an array by using one array for keys and another for its values.

Type Definition

typescript

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

source test1.0.0

Return a copy of the array with all falsy values removed.

Type Definition

typescript

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

source test1.0.0

Compose a list of functions.

Type Definition

typescript

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('licia'); // -> 'hi: LICIA!'

compressImg

source test demo1.0.0

Compress image using canvas.

Type Definition

typescript

function compressImg(
    file: File | Blob | string,
    cb: types.AnyFn
): void;
function compressImg(
    file: File | Blob | string,
    options?: {
        maxWidth?: number;
        maxHeight?: number;
        width?: number;
        height?: number;
        mimeType?: string;
        quality?: number;
    },
    cb?: types.AnyFn
): void;

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

source test1.0.0

Concat multiple arrays into a single array.

Type Definition

typescript

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

source test1.0.0

Check if the value is present in the list.

Type Definition

typescript

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

source test1.35.0

Get container stats inside container.

Type Definition

typescript

const container: {
    cpuNum(): number;
    cpuUsage(period?: number): Promise<number>;
    cpuLoad(period?: number): Promise<number>;
    memUsage(): number;
    memLoad(): number;
};

javascript

container.cpuNum();

convertBase

source test1.0.0

Convert base of a number.

Type Definition

typescript

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

source test1.5.0

Convert binary data type.

Type Definition

typescript

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...
});

source test1.0.0

Simple api for handling browser cookies.

Type Definition

typescript

namespace cookie {
    interface IOptions {
        path?: string;
        expires?: number;
        domain?: string;
        secure?: boolean;
    }
    interface ICookie {
        get(key: string, options?: cookie.IOptions): string;
        set(key: string, val: string, options?: cookie.IOptions): ICookie;
        remove(key: string, options?: cookie.IOptions): ICookie;
    }
}
const cookie: cookie.ICookie;

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

source test demo1.0.0

Copy text to clipboard using document.execCommand.

Type Definition

typescript

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

source test1.5.7

CRC1 implementation.

Type Definition

typescript

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

source test1.5.9

CRC16 implementation.

Type Definition

typescript

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

source test1.5.9

CRC32 implementation.

Type Definition

typescript

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

source test1.5.9

CRC8 implementation.

Type Definition

typescript

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

source test1.16.0

Create new object using given object as prototype.

Type Definition

typescript

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

source test1.0.0

Used to create extend, extendOwn and defaults.

Type Definition

typescript

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

source test1.0.0

CreateObjectURL wrapper.

Type Definition

typescript

function createUrl(
    data: any,
    options?: { type?: string }
): string;

Name	Desc
data	Url data
options	Used when data is not a File or Blob
return	Blob url

javascript

createUrl('test', { type: 'text/plain' }); // -> Blob url
createUrl(['test', 'test']);
createUrl(new Blob([]));
createUrl(new File(['test'], 'test.txt'));

css

source test1.14.0

Css parser and serializer.

Type Definition

typescript

const css: {
    parse(css: string): object;
    stringify(stylesheet: object, options?: { indent?: string }): string;
};

Comments will be stripped.

parse

Parse css into js object.

Name	Desc
css	Css string
return	Parsed js object

stringify

Stringify object into css.

Name	Desc
stylesheet	Object to stringify
options	Stringify options
return	Css string

Options:

Name	Desc
indent=' '	String used to indent

javascript

const stylesheet = css.parse('.name { background: #000; color: red; }');
// {type: 'stylesheet', rules: [{type: 'rule', selector: '.name', declarations: [...]}]}
css.stringify(stylesheet);

cssPriority

source test1.29.0

Calculate and compare priority of css selector/rule.

Type Definition

typescript

namespace cssPriority {
    function compare(p1: number[], p2: number[]): number;
}
function cssPriority(
    selector: string,
    options?: {
        important?: boolean;
        inlineStyle?: boolean;
        position?: number;
    }
): number[];

Name	Type
selector	CSS selector
options	Rule extra info
return	Priority array

Priority array contains five number values.

Important mark
Inline style
ID selector
Class selectors
Type selectors
Rule position

compare

Compare priorities.

Name	Desc
p1	Priority to compare
p2	Priority to compare
return	Comparison result

javascript

cssPriority('a.button > i.icon:before', {
    important: true,
    inlineStyle: false,
    position: 100
}); // -> [1, 0, 0, 2, 3, 100]

cssSupports

source test1.0.0

Check if browser supports a given CSS feature.

Type Definition

typescript

function cssSupports(name: string, val?: string): boolean;

Name	Desc
name	Css property name
val	Css property value
return	True if supports

javascript

cssSupports('display', 'flex'); // -> true
cssSupports('display', 'invalid'); // -> false
cssSupports('text-decoration-line', 'underline'); // -> true
cssSupports('grid'); // -> true
cssSupports('invalid'); // -> false

curry

source test1.0.0

Function currying.

Type Definition

typescript

function curry(fn: types.AnyFn): types.AnyFn;

Name	Desc
fn	Function to curry
return	New curried function

javascript

const add = curry(function(a, b) {
    return a + b;
});
const add1 = add(1);
add1(2); // -> 3

dataUrl

source test1.41.0

Parse and stringify data urls.

Type Definition

typescript

const dataUrl: {
    parse(
        dataUrl: string
    ): { data: string; mime: string; charset: string; base64: boolean } | null;
    stringify(
        data: any,
        mime: string,
        options?: { base64?: boolean; charset?: string }
    ): string;
};

parse

Parse a data url.

Name	Desc
dataUrl	Data url string
return	Parsed object

stringify

Stringify an object into a data url.

Name	Desc
data	Data to stringify
mime	Mime type
options	Stringify options
return	Data url string

options

Name	Desc
base64=true	Whether is base64
charset	Charset

javascript

dataUrl.parse('data:,Hello%2C%20World%21'); // -> {data: 'Hello, World!', mime: 'text/plain', charset: '', base64: false}
dataUrl.stringify('Hello, World!', 'text/plain'); // -> 'data:,Hello%2C%20World%21'

dateFormat

source test1.0.0

Simple but extremely useful date format function.

Type Definition

typescript

function dateFormat(
    date: Date,
    mask: string,
    utc?: boolean,
    gmt?: boolean
): string;
function dateFormat(
    mask: string,
    utc?: boolean,
    gmt?: boolean
): string;

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

source test1.0.0

Return a new debounced version of the passed function.

Type Definition

typescript

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

source test demo1.0.0

A tiny JavaScript debugging utility.

Type Definition

typescript

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

source test1.6.1

Convert Latin-1 Supplement and Latin Extended-A letters to basic Latin letters and remove combining diacritical marks.

Type Definition

typescript

function deburr(str: string): string;

Name	Desc
str	String to deburr
return	Deburred string

javascript

deburr('déjà vu'); // -> 'deja vu'

decodeUriComponent

source test1.0.0

Better decodeURIComponent that does not throw if input is invalid.

Type Definition

typescript

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

source test1.0.0

Fill in undefined properties in object with the first value present in the following list of defaults objects.

Type Definition

typescript

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

source test1.0.0

Define a module, should be used along with use.

Type Definition

typescript

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

source test1.0.0

Shortcut for Object.defineProperty(defineProperties).

Type Definition

typescript

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

source test1.16.0

Return the first argument that is not undefined.

Type Definition

typescript

function defined(...args: any[]): any;

Name	Desc
...args	Arguments to check
return	First defined argument

javascript

defined(false, 2, void 0, 100); // -> false

delRequireCache

source test1.5.4

Delete node.js require cache.

Type Definition

typescript

function delRequireCache(id: string): void;

Name	Desc
id	Module name or path

javascript

const licia = require('licia');
licia.a = 5;
delRequireCache('licia');
require('licia').a; // -> undefined

delay

source test1.0.0

Invoke function after certain milliseconds.

Type Definition

typescript

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

source test1.0.0

Event delegation.

Type Definition

typescript

const delegate: {
    add(el: Element, type: string, selector: string, cb: types.AnyFn): void;
    remove(el: Element, type: string, selector: string, cb: types.AnyFn): void;
};

add

Add event delegation.

Name	Desc
el	Parent element
type	Event type
selector	Match selector
cb	Event callback

remove

Remove event delegation.

javascript

const container = document.getElementById('container');
function clickHandler() {
    // Do something...
}
delegate.add(container, 'click', '.children', clickHandler);
delegate.remove(container, 'click', '.children', clickHandler);

deprecate

source test demo1.5.0

Node.js util.deprecate with browser support.

Type Definition

typescript

function deprecate(fn: types.AnyFn, msg: string): types.AnyFn;

Name	Desc
fn	Function to be deprecated
msg	Warning message
return	Deprecated function

javascript

const fn = () => {};
const obsoleteFn = deprecate(fn, 'obsoleteFn is deprecated.');
obsoleteFn();

detectBrowser

source test1.0.0

Detect browser info using ua.

Type Definition

typescript

function detectBrowser(
    ua?: string
): {
    name: string;
    version: number;
};

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

source test1.0.0

Detect if mocha is running.

Type Definition

typescript

function detectMocha(): boolean;

javascript

detectMocha(); // -> True if mocha is running.

detectOs

source test1.0.0

Detect operating system using ua.

Type Definition

typescript

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

source test1.0.0

Create an array of unique array values not included in the other given array.

Type Definition

typescript

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

source test1.0.0

Convert string to "dotCase".

Type Definition

typescript

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

source test demo1.0.0

Trigger a file download on client side.

Type Definition

typescript

function download(
    data: Blob | File | string | any[],
    name: string,
    type?: string
): void;

Name	Desc
data	Data to download
name	File name
type=text/plain	Data type

javascript

download('test', 'test.txt');

durationFormat

source test1.18.0

Simple duration format function.

Type Definition

typescript

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

source test benchmark1.0.0

Iterate over elements of collection and invokes iterator for each element.

Type Definition

typescript

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

source test1.0.0

Easing functions adapted from http://jqueryui.com/ .

Type Definition

typescript

const easing: {
    linear(percent: number): number;
    inQuad(percent: number): number;
    outQuad(percent: number): number;
    inOutQuad(percent: number): number;
    outInQuad(percent: number): number;
    inCubic(percent: number): number;
    outCubic(percent: number): number;
    inQuart(percent: number): number;
    outQuart(percent: number): number;
    inQuint(percent: number): number;
    outQuint(percent: number): number;
    inExpo(percent: number): number;
    outExpo(percent: number): number;
    inSine(percent: number): number;
    outSine(percent: number): number;
    inCirc(percent: number): number;
    outCirc(percent: number): number;
    inElastic(percent: number, elasticity?: number): number;
    outElastic(percent: number, elasticity?: number): number;
    inBack(percent: number): number;
    outBack(percent: number): number;
    inOutBack(percent: number): number;
    outInBack(percent: number): number;
    inBounce(percent: number): number;
    outBounce(percent: number): number;
};

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

source test demo1.9.0

Emulate touch events on desktop browsers.

Type Definition

typescript

function emulateTouch(el: Element): void;

Name	Desc
el	Target element

javascript

const el = document.querySelector('#test');
emulateTouch(el);
el.addEventListener('touchstart', () => {}, false);

endWith

source test1.0.0

Check if string ends with the given target string.

Type Definition

typescript

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

source test1.0.0

Escapes a string for insertion into HTML, replacing &, <, >, ", `, and ' characters.

Type Definition

typescript

function escape(str: string): string;

Name	Desc
str	String to escape
return	Escaped string

javascript

escape('You & Me'); // -> 'You &amp; Me'

escapeJsStr

source test1.0.0

Escape string to be a valid JavaScript string literal between quotes.

Type Definition

typescript

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

source test1.0.0

Escape special chars to be used as literals in RegExp constructors.

Type Definition

typescript

function escapeRegExp(str: string): string;

Name	Desc
str	String to escape
return	Escaped string

javascript

escapeRegExp('[licia]'); // -> '\\[licia\\]'

evalCss

source test1.0.0

Load css into page.

Type Definition

typescript

function evalCss(css: string): HTMLStyleElement;

Name	Desc
css	Css code
return	Style element

javascript

evalCss('body{background:#08c}');

evalJs

source test benchmark1.0.0

Execute js in given context.

Type Definition

typescript

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

source test1.0.0

Check if predicate return truthy for all elements.

Type Definition

typescript

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

source test1.0.0

Copy all of the properties in the source objects over to the destination object.

Type Definition

typescript

function extend(destination: any, ...sources: any[]): any;

Name	Desc
destination	Destination object
...sources	Sources objects
return	Destination object

javascript

extend({ name: 'RedHood' }, { age: 24 }); // -> {name: 'RedHood', age: 24}

extendDeep

source test1.0.0

Recursive object extending.

Type Definition

typescript

function extendDeep(destination: any, ...sources: any[]): any;

Name	Desc
destination	Destination object
...sources	Sources objects
return	Destination object

javascript

extendDeep(
    {
        name: 'RedHood',
        family: {
            mother: 'Jane',
            father: 'Jack'
        }
    },
    {
        family: {
            brother: 'Bruce'
        }
    }
);
// -> {name: 'RedHood', family: {mother: 'Jane', father: 'Jack', brother: 'Bruce'}}

extendOwn

source test1.0.0

Like extend, but only copies own properties over to the destination object.

Type Definition

typescript

function extendOwn(destination: any, ...sources: any[]): any;

Name	Desc
destination	Destination object
...sources	Sources objects
return	Destination object

javascript

extendOwn({ name: 'RedHood' }, { age: 24 }); // -> {name: 'RedHood', age: 24}

extractBlockCmts

source test1.0.0

Extract block comments from source code.

Type Definition

typescript

function extractBlockCmts(str: string): string[];

Name	Desc
str	String to extract
return	Block comments

javascript

extractBlockCmts('\/*licia*\/'); // -> ['licia']

extractUrls

source test1.0.0

Extract urls from plain text.

Type Definition

typescript

function extractUrls(str: string): string[];

Name	Desc
str	Text to extract
return	Url list

javascript

const str =
    '[Official site: http://eustia.liriliri.io](http://eustia.liriliri.io)';
extractUrls(str); // -> ['http://eustia.liriliri.io']

fetch

source test1.0.0

Turn XMLHttpRequest into promise like.

Type Definition

typescript

namespace fetch {
    interface IResult {
        ok: boolean;
        status: number;
        statusText: string;
        url: string;
        clone(): IResult;
        text(): Promise<string>;
        json(): Promise<any>;
        xml(): Promise<Document | null>;
        blob(): Promise<Blob>;
        headers: {
            keys(): string[];
            entries(): Array<string[]>;
            get(name: string): string;
            has(name: string): boolean;
        };
    }
}
function fetch(
    url: string,
    options?: {
        method?: string;
        timeout?: number;
        headers?: types.PlainObj<string>;
        body?: any;
    }
): Promise<fetch.IResult>;

Note: This is not a complete fetch pollyfill.

Name	Desc
url	Request url
options	Request options
return	Request promise

javascript

fetch('test.json', {
    method: 'GET',
    timeout: 3000,
    headers: {},
    body: ''
})
    .then(function(res) {
        return res.json();
    })
    .then(function(data) {
        console.log(data);
    });

fibonacci

source test1.0.0

Calculate fibonacci number.

Type Definition

typescript

function fibonacci(n: number): number;

Name	Desc
n	Index of fibonacci sequence
return	Expected fibonacci number

javascript

fibonacci(1); // -> 1
fibonacci(3); // -> 2

fileSize

source test1.0.0

Turn bytes into human readable file size.

Type Definition

typescript

function fileSize(bytes: number): string;

Name	Desc
bytes	File bytes
return	Readable file size

javascript

fileSize(5); // -> '5'
fileSize(1500); // -> '1.46K'
fileSize(1500000); // -> '1.43M'
fileSize(1500000000); // -> '1.4G'
fileSize(1500000000000); // -> '1.36T'

fileType

source test1.5.1

Detect file type using magic number.

Type Definition

typescript

function fileType(
    input: Buffer | ArrayBuffer | Uint8Array
):
    | {
          ext: string;
          mime: string;
      }
    | undefined;

Name	Desc
input	File input
return	Object containing ext and mime

Supported file types

jpg, png, gif, webp, bmp, gz, zip, rar, pdf, exe

javascript

const fs = require('fs');
const file = fs.readFileSync('path/to/file');
console.log(fileType(file)); // -> { ext: 'jpg', mime: 'image/jpeg' }

fileUrl

source test1.36.0

Convert a file path to a file URL.

Type Definition

typescript

function fileUrl(path: string): string;

Name	Desc
path	File path
return	File URL

javascript

fileUrl('c:\\foo\\bar'); // -> 'file:///c:/foo/bar'

fill

source test1.0.0

Fill elements of array with value.

Type Definition

typescript

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

source test1.0.0

Iterates over elements of collection, returning an array of all the values that pass a truth test.

Type Definition

typescript

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

source test1.0.0

Find the first value that passes a truth test in a collection.

Type Definition

typescript

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

source test1.0.0

Return the first index where the predicate truth test passes.

Type Definition

typescript

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

source test1.0.0

Return the first key where the predicate truth test passes.

Type Definition

typescript

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

source test1.0.0

Return the last index where the predicate truth test passes.

Type Definition

typescript

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

source test1.0.0

Recursively flatten an array.

Type Definition

typescript

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

source test1.5.3

Validate function arguments.

Type Definition

typescript

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

source test1.0.0

Get a function parameter's names.

Type Definition

typescript

function fnParams(fn: types.AnyFn | string): string[];

Name	Desc
fn	Function to get parameters
return	Names

javascript

fnParams(function(a, b) {}); // -> ['a', 'b']

fnv1a

source test1.10.0

Simple FNV-1a implementation.

Type Definition

typescript

function fnv1a(str: string): number;

Name	Desc
str	String to hash
return	Hast result

javascript

fnv1a('test'); // -> 2949673445

format

source test1.0.0

Format string in a printf-like format.

Type Definition

typescript

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

source test1.0.0

Convert number to fraction.

Type Definition

typescript

function fraction(num: number): string;

Name	Desc
num	Number to convert
return	Corresponding fraction

javascript

fraction(1.2); // -> '6/5'

freeze

source test1.0.0

Shortcut for Object.freeze.

Type Definition

typescript

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

source test1.0.0

Recursively use Object.freeze.

Type Definition

typescript

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

source test1.0.0

Promised version of node.js fs module.

Type Definition

typescript

const fs: {
    readFile(path: string, encoding: string): Promise<string>;
    readFile(path: string): Promise<Buffer>;
    exists(path: string): Promise<boolean>;
    unlink(path: string): Promise<void>;
    writeFile(path: string, data: string, options?: string): Promise<void>;
    writeFile(path: string, data: Buffer): Promise<void>;
    readdir(path: string): Promise<string[]>;
    rmdir(path: string): Promise<void>;
    [key: string]: any;
};

javascript

fs.readFile('test.js')
    .then(function(data) {
        // Do something
    })
    .catch(function(err) {
        // Handle errors
    });

fullscreen

source test demo1.4.0

Fullscreen api wrapper.

Type Definition

typescript

namespace fullscreen {
    interface IFullscreen extends Emitter {
        request(el?: Element): void;
        exit(): void;
        toggle(el?: Element): void;
        isActive(): boolean;
        getEl(): Element | null;
        isEnabled(): boolean;
    }
}
const fullscreen: fullscreen.IFullscreen;

request

Request fullscreen.

Name	Desc
el	Fullscreen element

exit

Exit fullscreen.

toggle

Toggle fullscreen.

Name	Desc
el	Fullscreen element

isActive

Check Whether fullscreen is active.

getEl

Return Fullscreen element if exists.

isEnabled

Whether you are allowed to enter fullscreen.

javascript

fullscreen.request();
fullscreen.isActive(); // -> false, not a synchronous api
fullscreen.on('error', () => {});
fullscreen.on('change', () => {});

fuzzySearch

source test1.5.0

Simple fuzzy search.

Type Definition

typescript

function fuzzySearch(
    needle: string,
    haystack: any[],
    options?: {
        caseSensitive?: boolean;
        key?: string | string[];
    }
): any[];

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', ['licia', 'll', 'lic']); // -> ['lic', 'licia']
fuzzySearch(
    'alpha-test',
    [
        {
            name: 'alpha-test-1'
        },
        {
            name: 'beta-test'
        }
    ],
    {
        key: 'name'
    }
); // -> [{ name: 'alpha-test-1' }]

gcd

source test1.0.0

Compute the greatest common divisor using Euclid's algorithm.

Type Definition

typescript

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

source test1.1.0

Get an available TCP port.

Type Definition

typescript

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

source test1.5.5

Get prototype of an object.

Type Definition

typescript

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

source test1.0.0

Get url param.

Type Definition

typescript

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

source test1.5.4

Handle errors like golang.

Type Definition

typescript

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

source test1.5.1

Create html with JavaScript.

Type Definition

typescript

function h(
    tag: string,
    attrs?: types.PlainObj<any>,
    ...child: Array<string | HTMLElement>
): HTMLElement;

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

source test1.0.0

Checks if key is a direct property.

Type Definition

typescript

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

source test1.11.0

Heap sort implementation.

Type Definition

typescript

function heapSort(arr: any[], cmp?: types.AnyFn): any[];

Name	Desc
arr	Array to sort
cmp	Comparator
return	Sorted array

javascript

heapSort([2, 1]); // -> [1, 2]

hex

source test1.15.0

Hex encoding and decoding.

Type Definition

typescript

const hex: {
    encode(bytes: number[]): string;
    decode(str: string): number[];
};

encode

Turn a byte array into a hex string.

Name	Desc
bytes	Byte array
return	hex string

decode

Turn a hex string into a byte array.

Name	Desc
str	hex string
return	Byte array

javascript

hex.encode([168, 174, 155, 255]); // -> 'a8ae9bff'
hex.decode('a8ae9bff'); // -> [168, 174, 155, 255]

highlight

source test demo1.5.6

Highlight code.

Type Definition

typescript

function highlight(
    str: string,
    lang?: string,
    style?: {
        comment?: string;
        string?: string;
        number?: string;
        keyword?: string;
        operator?: string;
    }
): string;

Name	Desc
str	Code string
lang=js	Language, js, html or css
style	Keyword highlight style
return	Highlighted html code string

Available styles:

comment, string, number, keyword, operator

javascript

highlight('const a = 5;', 'js', {
    keyword: 'color:#569cd6;'
}); // -> '<span class="keyword" style="color:#569cd6;">const</span> a <span class="operator" style="color:#994500;">=</span> <span class="number" style="color:#0086b3;">5</span>;'

hookFn

source test1.34.0

Monitor, change function arguments and result.

Type Definition

typescript

function hookFn<T>(
    fn: T,
    options: {
        before?: types.AnyFn;
        after?: types.AnyFn;
        error?: types.AnyFn;
    }
): T;

Name	Desc
fn	Function to hook
options	Hook options
return	Hooked function

Available options:

Name	Desc
before	Arguments handler
after	Result handler
error	Error handler

javascript

let sum = function(a, b) {
    if (a > 100) {
        throw Error('a is bigger than 100');
    }
    return a + b;
};
let totalSum = 0;
sum = hookFn(sum, {
    before(a, b) {
        return [+a, +b];
    },
    after(result) {
        totalSum += result;
        return totalSum;
    },
    error() {
        return totalSum;
    }
});
sum('2', '5'); // -> 7

hotkey

source test demo1.0.0

Capture keyboard input to trigger given events.

Type Definition

typescript

namespace hotkey {
    interface IOptions {
        element?: HTMLElement;
    }
}
const hotkey: {
    on(key: string, options: hotkey.IOptions, listener: types.AnyFn): void;
    on(key: string, listener: types.AnyFn): void;
    off(key: string, options: hotkey.IOptions, listener: types.AnyFn): void;
    off(key: string, listener: types.AnyFn): void;
};

on

Name	Desc
key	Key string
options	Hotkey options
listener	Key listener

Options:

Name	Desc
element=document	Target element

off

Unregister keyboard listener.

javascript

const container = document.getElementById('container');
hotkey.on(
    'k',
    {
        element: container
    },
    function() {
        console.log('k is pressed');
    }
);
function keyDown() {}
hotkey.on('shift+a, shift+b', keyDown);
hotkey.off('shift+a', keyDown);

hslToRgb

source test1.0.0

Convert hsl to rgb.

Type Definition

typescript

function hslToRgb(hsl: number[]): number[];

Name	Desc
hsl	Hsl values
return	Rgb values

javascript

hslToRgb([165, 59, 50, 0.8]); // -> [52, 203, 165, 0.8]

html

source test1.6.0

Html parser and serializer.

Type Definition

typescript

const html: {
    parse(html: string): any[];
    stringify(tree: any[]): string;
};

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('<div id="name">licia</div>');
// -> [{tag: 'div', attrs: {id: 'name'}, content: ['licia']}]
html.stringify(tree);

identity

source test1.0.0

Return the first argument given.

Type Definition

typescript

function identity<T>(val: T): T;

Name	Desc
val	Any value
return	Given value

javascript

identity('a'); // -> 'a'

idxOf

source test1.0.0

Get the index at which the first occurrence of value.

Type Definition

typescript

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

source test1.0.0

Indent each line in a string.

Type Definition

typescript

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

source test1.0.0

Inherit the prototype methods from one constructor into another.

Type Definition

typescript

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

source test1.5.4

Ini parser and serializer.

Type Definition

typescript

const ini: {
    parse(ini: string): any;
    stringify(
        obj: any,
        options?: {
            section?: string;
            whitespace: boolean;
        }
    ): string;
};

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 = licia

[user.info]
name = surunzi
alias[] = redhoodsu
alias[] = red
`); // -> {library: 'licia', user: {info: {name: 'surunzi', alias: ['redhoodsu', 'red']}}}

ini.stringify(config);

insertionSort

source test1.0.0

Insertion sort implementation.

Type Definition

typescript

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

source test1.0.0

Compute the list of values that are the intersection of all the arrays.

Type Definition

typescript

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

source test1.0.0

Intersect two ranges.

Type Definition

typescript

namespace intersectRange {
    interface IRange {
        start: number;
        end: number;
    }
}
function intersectRange(
    a: intersectRange.IRange,
    b: intersectRange.IRange
): intersectRange.IRange | void;

Name	Desc
a	Range a
b	Range b
return	Intersection if exist

javascript

intersectRange({ start: 0, end: 12 }, { start: 11, end: 13 });
// -> {start: 11, end: 12}
intersectRange({ start: 0, end: 5 }, { start: 6, end: 7 });
// -> undefined

invariant

source test1.17.0

Facebook's invariant.

Type Definition

typescript

function invariant(
    condition: boolean,
    format?: string,
    a?: string,
    b?: string,
    c?: string,
    d?: string,
    e?: string,
    f?: string
): void;

Related docs

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

source test1.0.0

Create an object composed of the inverted keys and values of object.

Type Definition

typescript

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

source test1.0.0

Check if an url is absolute.

Type Definition

typescript

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

source test1.0.0

Check if value is classified as an arguments object.

Type Definition

typescript

function isArgs(val: any): val is IArguments;

Name	Desc
val	Value to check
return	True if value is an arguments object

javascript

isArgs(
    (function() {
        return arguments;
    })()
); // -> true

isArr

source test1.0.0

Check if value is an Array object.

Type Definition

typescript

function isArr(val: any): val is any[];

Name	Desc
val	Value to check
return	True if value is an `Array` object

javascript

isArr([]); // -> true
isArr({}); // -> false

isArrBuffer

source test1.0.0

Check if value is an ArrayBuffer.

Type Definition

typescript

function isArrBuffer(val: any): val is ArrayBuffer;

Name	Desc
val	Value to check
return	True if value is an ArrayBuffer

javascript

isArrBuffer(new ArrayBuffer(8)); // -> true

isArrLike

source test1.0.0

Check if value is array-like.

Type Definition

typescript

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

source test1.17.0

Check if value is an async function.

Type Definition

typescript

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

source test1.0.0

Check if value is a Blob.

Type Definition

typescript

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

source test1.0.0

Check if value is a boolean primitive.

Type Definition

typescript

function isBool(val: any): val is 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

source test1.0.0

Check if running in a browser.

Type Definition

typescript

const isBrowser: boolean;

javascript

console.log(isBrowser); // -> true if running in a browser

isBuffer

source test1.0.0

Check if value is a buffer.

Type Definition

typescript

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

source test1.0.0

Check if values are close(almost equal) to each other.

Type Definition

typescript

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

source test benchmark1.30.0

Detect cyclic object reference.

Type Definition

typescript

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

source test1.19.0

Detect dark mode.

Type Definition

typescript

function isDarkMode(): boolean;

javascript

console.log(isDarkMode()); // true if dark mode

isDataUrl

source test1.0.0

Check if a string is a valid data url.

Type Definition

typescript

function isDataUrl(str: string): boolean;

Name	Desc
str	String to check
return	True if string is a data url

javascript

isDataUrl('http://eustia.liriliri.io'); // -> false
isDataUrl('data:text/plain;base64,SGVsbG8sIFdvcmxkIQ%3D%3D'); // -> true

isDate

source test1.0.0

Check if value is classified as a Date object.

Type Definition

typescript

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

source test1.28.0

Check if a path is directory.

Type Definition

typescript

function isDir(path: string): Promise<boolean>;

Name	Desc
path	Path to check
return	True if path is a directory

javascript

isDir('/foo/bar');

isDocker

source test1.35.0

Check if the process is running inside a docker container.

Type Definition

typescript

function isDocker(): boolean;

javascript

console.log(isDocker()); // -> true if running inside a docker container.

isEl

source test1.0.0

Check if value is a DOM element.

Type Definition

typescript

function isEl(val: any): val is Element;

Name	Desc
val	Value to check
return	True if value is a DOM element

javascript

isEl(document.body); // -> true

isEmail

source test1.0.0

Loosely validate an email address.

Type Definition

typescript

function isEmail(val: string): boolean;

Name	Desc
val	Value to check
return	True if value is an email like string

javascript

isEmail('[email protected]'); // -> true

isEmpty

source test1.0.0

Check if value is an empty object or array.

Type Definition

typescript

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

source test1.0.0

Performs an optimized deep comparison between the two objects, to determine if they should be considered equal.

Type Definition

typescript

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

source test1.0.0

Check if value is an error.

Type Definition

typescript

function isErr(val: any): val is Error;

Name	Desc
val	Value to check
return	True if value is an error

javascript

isErr(new Error()); // -> true

isEven

source test1.0.0

Check if number is even.

Type Definition

typescript

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

source test1.0.0

Check if value is a file.

Type Definition

typescript

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

source test1.0.0

Check if value is a finite primitive number.

Type Definition

typescript

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

source test1.0.0

Check if value is a function.

Type Definition

typescript

function isFn(val: any): val is Function;

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

source test1.24.0

Check if character is full width.

Type Definition

typescript

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

source test1.0.0

Check if value is a generator function.

Type Definition

typescript

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

source test1.18.0

Check if element is hidden.

Type Definition

typescript

function isHidden(
    el: Element,
    options?: {
        display?: boolean;
        visibility?: boolean;
        opacity?: boolean;
        size?: boolean;
        viewport?: boolean;
        overflow?: boolean;
    }
): boolean;

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

source test1.0.0

Checks if value is classified as a Integer.

Type Definition

typescript

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

source test1.5.1

Check if value is an IP address.

Type Definition

typescript

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

source test1.0.0

Check if value is a valid JSON.

Type Definition

typescript

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

source test1.0.0

Check if a year is a leap year.

Type Definition

typescript

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

isMac

source test1.40.0

Check if platform is mac.

Type Definition

typescript

const isMac: boolean;

javascript

console.log(isMac); // -> true if running on mac

isMap

source test1.0.0

Check if value is a Map object.

Type Definition

typescript

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

source test1.0.0

Check if keys and values in src are contained in obj.

Type Definition

typescript

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

source test1.0.0

Check if running in wechat mini program.

Type Definition

typescript

const isMiniProgram: boolean;

javascript

console.log(isMiniProgram); // -> true if running in mini program.

isMobile

source test1.0.0

Check whether client is using a mobile browser using ua.

Type Definition

typescript

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

source test1.0.0

Check if value is an NaN.

Type Definition

typescript

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

source test1.0.0

Check if value is a native function.

Type Definition

typescript

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

source test1.0.0

Check if value is null or undefined, the same as value == null.

Type Definition

typescript

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

source test1.0.0

Check if running in node.

Type Definition

typescript

const isNode: boolean;

javascript

console.log(isNode); // -> true if running in node

isNull

source test1.0.0

Check if value is an Null.

Type Definition

typescript

function isNull(val: any): val is null;

Name	Desc
val	Value to check
return	True if value is an Null

javascript

isNull(null); // -> true

isNum

source test1.0.0

Check if value is classified as a Number primitive or object.

Type Definition

typescript

function isNum(val: any): val is number;

Name	Desc
val	Value to check
return	True if value is correctly classified

javascript

isNum(5); // -> true
isNum(5.1); // -> true
isNum({}); // -> false

isNumeric

source test1.0.0

Check if value is numeric.

Type Definition

typescript

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

source test1.0.0

Check if value is the language type of Object.

Type Definition

typescript

function isObj(val: any): boolean;

Name	Desc
val	Value to check
return	True if value is an object

Language Spec

javascript

isObj({}); // -> true
isObj([]); // -> true

isOdd

source test1.0.0

Check if number is odd.

Type Definition

typescript

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

source test1.0.0

Check if value is an object created by Object constructor.

Type Definition

typescript

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

source test1.5.2

Check if a TCP port is free.

Type Definition

typescript

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

source test1.2.0

Check if the provided integer is a prime number.

Type Definition

typescript

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

source test1.0.0

Check if value is string, number, boolean or null.

Type Definition

typescript

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

source test1.0.0

Check if value looks like a promise.

Type Definition

typescript

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

source test1.0.0

Check if value is a regular expression.

Type Definition

typescript

function isRegExp(val: any): val is RegExp;

Name	Desc
val	Value to check
return	True if value is a regular expression

javascript

isRegExp(/a/); // -> true

isRelative

source test1.0.0

Check if path appears to be relative.

Type Definition

typescript

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

source test1.0.0

Determine if running on a high DPR device or not.

Type Definition

typescript

const isRetina: boolean;

javascript

console.log(isRetina); // -> true if high DPR

isRunning

source test1.22.0

Check if process is running.

Type Definition

typescript

function isRunning(pid: number): boolean;

Name	Desc
pid	Process id
return	True if process is running

javascript

isRunning(123456); // true if running

isSet

source test1.0.0

Check if value is a Set object.

Type Definition

typescript

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

source test1.0.0

Check if an array is sorted.

Type Definition

typescript

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

source test1.0.0

Check if value is a string primitive.

Type Definition

typescript

function isStr(val: any): val is string;

Name	Desc
val	Value to check
return	True if value is a string primitive

javascript

isStr('licia'); // -> true

isStrBlank

source test benchmark1.39.0

Check if string is blank.

Type Definition

typescript

function isStrBlank(str: string): boolean;

Name	Desc
str	String to check
return	True if string is blank

javascript

isStrBlank('licia'); // -> false
isStrBlank(''); // -> true
isStrBlank('    '); // -> true
isStrBlank('\r\n '); // -> true

isStream

source test1.0.0

Check if value is a Node.js stream.

Type Definition

typescript

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

source test1.5.5

Check if value is a symbol.

Type Definition

typescript

function isSymbol(val: any): val is symbol;

Name	Desc
val	Value to check
return	True if value is a symbol

javascript

isSymbol(Symbol('test')); // -> true

isTypedArr

source test1.0.0

Check if value is a typed array.

Type Definition

typescript

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

source test1.0.0

Check if value is undefined.

Type Definition

typescript

function isUndef(val: any): val is undefined;

Name	Desc
val	Value to check
return	True if value is undefined

javascript

isUndef(void 0); // -> true
isUndef(null); // -> false

isUrl

source test1.0.0

Loosely validate an url.

Type Definition

typescript

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&param=test'); // -> true

isWeakMap

source test1.0.0

Check if value is a WeakMap object.

Type Definition

typescript

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

source test1.0.0

Check if value is a WeakSet object.

Type Definition

typescript

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

source test1.0.0

Check if platform is windows.

Type Definition

typescript

const isWindows: boolean;

javascript

console.log(isWindows); // -> true if running on windows

jsonClone

source test1.12.0

Use JSON parse and stringify to clone object.

Type Definition

typescript

function jsonClone<T>(val: T): T;

Name	Desc
val	Value to clone
return	Cloned value

javascript

jsonClone({ name: 'licia' }); // -> { name: 'licia' }

jsonp

source test1.0.0

A simple jsonp implementation.

Type Definition

typescript

function jsonp(options: {
    url: string;
    data?: any;
    success?: types.AnyFn;
    param?: string;
    name?: string;
    error?: types.AnyFn;
    complete?: types.AnyFn;
    timeout?: number;
}): void;

Name	Desc
options	Jsonp Options

Available options:

Name	Desc
url	Request url
data	Request data
success	Success callback
param=callback	Callback param
name	Callback name
error	Error callback
complete	Callback after request
timeout	Request timeout

javascript

jsonp({
    url: 'http://example.com',
    data: { test: 'true' },
    success: function(data) {
        // ...
    }
});

kebabCase

source test1.0.0

Convert string to "kebabCase".

Type Definition

typescript

function kebabCase(str: string): string;

Name	Desc
str	String to convert
return	Kebab cased string

javascript

kebabCase('fooBar'); // -> foo-bar
kebabCase('foo bar'); // -> foo-bar
kebabCase('foo_bar'); // -> foo-bar
kebabCase('foo.bar'); // -> foo-bar

keyCode

source test1.0.0

Key codes and key names conversion.

Type Definition

typescript

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

source test1.0.0

Create an array of the own enumerable property names of object.

Type Definition

typescript

function keys(obj: any): string[];

Name	Desc
obj	Object to query
return	Array of property names

javascript

keys({ a: 1 }); // -> ['a']

kill

source test1.4.4

Kill process.

Type Definition

typescript

function kill(pid: number): void;

Name	Desc
pid	Process ID

javascript

kill(9420);

last

source test1.0.0

Get the last element of array.

Type Definition

typescript

function last(arr: any[]): any;

Name	Desc
arr	The array to query
return	The last element of array

javascript

last([1, 2]); // -> 2

lazyImport

source test1.31.0

Import modules lazily, Proxy is used.

Type Definition

typescript

function lazyImport<T>(
    importFn: (moduleId: string) => T,
    dirname?: string
): (moduleId: string) => T;

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

source test1.0.0

Require modules lazily.

Type Definition

typescript

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

source test1.4.8

Levenshtein distance implementation.

Type Definition

typescript

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

source test1.0.0

Hyperlink urls in a string.

Type Definition

typescript

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.liriliri.io';
linkify(str); // -> 'Official site: <a href="http://eustia.liriliri.io">http://eustia.liriliri.io</a>'
linkify(str, function(url) {
    return '<a href="' + url + '" target="_blank">' + url + '</a>';
});

loadCss

source test1.0.0

Inject link tag into page with given href value.

Type Definition

typescript

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

source test1.0.0

Load image with given src.

Type Definition

typescript

function loadImg(src: string, cb?: types.AnyFn): void;

Name	Desc
src	Image source
cb	Onload callback

javascript

loadImg('http://eustia.liriliri.io/img.jpg', function(err, img) {
    console.log(img.width, img.height);
});

loadJs

source test1.0.0

Inject script tag into page with given src value.

Type Definition

typescript

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

source test1.0.0

Get the longest item in an array.

Type Definition

typescript

function longest(arr: string[]): string;

Name	Desc
arr	Array to inspect
return	Longest item

javascript

longest(['a', 'abcde', 'abc']); // -> 'abcde'

lowerCase

source test1.0.0

Convert string to lower case.

Type Definition

typescript

function lowerCase(str: string): string;

Name	Desc
str	String to convert
return	Lower cased string

javascript

lowerCase('TEST'); // -> 'test'

lpad

source test1.0.0

Pad string on the left side if it's shorter than length.

Type Definition

typescript

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

source test1.0.0

Remove chars or white-spaces from beginning of string.

Type Definition

typescript

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

source test1.0.0

Create an array of values by running each element in collection through iteratee.

Type Definition

typescript

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

source test1.0.0

Map for objects.

Type Definition

typescript

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

source test1.0.0

Return a predicate function that checks if attrs are contained in an object.

Type Definition

typescript

function matcher(attrs: any): types.AnyFn;

Name	Desc
attrs	Object of property values to match
return	New predicate function

javascript

const filter = require('licia/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

source test1.0.0

Get maximum value of given numbers.

Type Definition

typescript

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

source test benchmark1.1.0

MD5 implementation.

Type Definition

typescript

function md5(msg: string | number[]): string;

Name	Desc
msg	Message to encrypt
return	MD5 hash

javascript

md5('licia'); // -> 'e59f337d85e9a467f1783fab282a41d0'

memStorage

source test1.0.0

Memory-backed implementation of the Web Storage API.

Type Definition

typescript

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', 'licia');

memoize

source test1.0.0

Memoize a given function by caching the computed result.

Type Definition

typescript

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

source test1.24.0

Merge the contents of arrays together into the first array.

Type Definition

typescript

function mergeArr<T, U>(
    first: ArrayLike<T>,
    ...arrays: ArrayLike<U>[]
): ArrayLike<T | U>;

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

source test1.0.0

Merge sort implementation.

Type Definition

typescript

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]

methods

source test1.0.0

Return a sorted list of the names of every method in an object.

Type Definition

typescript

function methods(obj: any): string[];

Name	Desc
obj	Object to check
return	Function names in object

javascript

methods(console); // -> ['Console', 'assert', 'dir', ...]

mime

source test1.5.0

Common mime types.

Type Definition

typescript

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

source test1.0.0

Get minimum value of given numbers.

Type Definition

typescript

function min(...num: number[]): number;

Name	Desc
...num	Numbers to calculate
return	Minimum value

javascript

min(2.3, 1, 4.5, 2); // 1

mkdir

source test1.0.0

Recursively create directories.

Type Definition

typescript

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

source test1.0.0

Tiny moment.js like implementation.

Type Definition

typescript

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

source test1.25.0

Morph a dom tree to match a target dom tree.

Type Definition

typescript

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 = 'licia';
morphDom(el1, el2);
console.log(el1.className); // -> 'licia'

morse

source test1.19.0

Morse code encoding and decoding.

Type Definition

typescript

const morse: {
    encode(txt: string): string;
    decode(morse: string): string;
};

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

source test1.0.0

Convert time string formats to milliseconds.

Type Definition

typescript

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

source test1.30.0

Sort values in natural order.

Type Definition

typescript

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

source test1.0.0

Create a function that negates the result of the predicate function.

Type Definition

typescript

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

source test1.0.0

Next tick for both node and browser.

Type Definition

typescript

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

source test1.0.0

A no-operation function.

Type Definition

typescript

function noop(): void;

javascript

noop(); // Does nothing

normalizeHeader

source test1.2.0

Normalize http header name.

Type Definition

typescript

function normalizeHeader(header: string): string;

Name	Desc
header	Header to normalize
return	Normalized header

javascript

normalizeHeader('content-type'); // -> 'Content-Type'
normalizeHeader('etag'); // -> 'ETag'

normalizePath

source test1.0.0

Normalize file path slashes.

Type Definition

typescript

function normalizePath(path: string): string;

Name	Desc
path	Path to normalize
return	Normalized path

javascript

normalizePath('\\foo\\bar\\'); // -> '/foo/bar/'
normalizePath('./foo//bar'); // -> './foo/bar'

normalizePhone

source test1.13.0

Normalize phone numbers into E.164 format.

Type Definition

typescript

function normalizePhone(
    phone: string,
    options: {
        countryCode: number;
        trunkPrefix?: boolean;
    }
): string;

Name	Desc
phone	Phone to normalize
options	Normalize options
return	Normalized phone

Available options:

Name	Desc
countryCode	Country code
trunkPrefix=false	True if local format has trunk prefix

javascript

normalizePhone('13512345678', {
    countryCode: 86
}); // -> '+8613512345678'
normalizePhone('(415) 555-2671', {
    countryCode: 1
}); // -> '+14155552671'
normalizePhone('020 7183 8750', {
    countryCode: 44,
    trunkPrefix: true
}); // -> '+442071838750'

notify

source test demo1.14.0

Wrapper for the Web Notifications API.

Type Definition

typescript

namespace notify {
    class Notification extends Emitter {
        constructor(title: string, options?: object);
        show(): void;
    }
}
function notify(title: string, options?: object): void;

Name	Desc
title	Notification title
options	Notification options

You can pass exactly the same options supported in the Web Notification.

Notification

Use this to create instance when certain events like close, show, click or error needed to be handled.

javascript

notify('licia', {
    body: 'This is the notification content'
});
const notification = new notify.Notification('licia', {
    body: 'This is the notification content'
});
notification.on('error', err => console.log(err));
notification.on('click', e => console.log(e));
notification.show();

now

source test1.0.0

Gets the number of milliseconds that have elapsed since the Unix epoch.

Type Definition

typescript

function now(): number;

javascript

now(); // -> 1468826678701

objToStr

source test1.0.0

Alias of Object.prototype.toString.

Type Definition

typescript

function objToStr(val: any): string;

Name	Desc
val	Source value
return	String representation of given value

javascript

objToStr(5); // -> '[object Number]'

omit

source test1.0.0

Opposite of pick.

Type Definition

typescript

function omit(
    obj: any,
    filter: string | string[] | Function
): any;

Name	Desc
obj	Source object
filter	Object filter
return	Filtered object

javascript

omit({ a: 1, b: 2 }, 'a'); // -> {b: 2}
omit({ a: 1, b: 2, c: 3 }, ['b', 'c']); // -> {a: 1}
omit({ a: 1, b: 2, c: 3, d: 4 }, function(val, key) {
    return val % 2;
}); // -> {b: 2, d: 4}

once

source test1.0.0

Create a function that invokes once.

Type Definition

typescript

function once(fn: types.AnyFn): types.AnyFn;

Name	Desc
fn	Function to restrict
return	New restricted function

javascript

function init() {}
const initOnce = once(init);
initOnce();
initOnce(); // -> init is invoked once

open

source test1.2.0

Open stuff like url, files.

Type Definition

typescript

function open(target: string): any;

Name	Desc
target	Stuff to open
return	Child process

javascript

open('https://eustia.liriliri.io/');

openFile

source test demo1.3.0

Open file dialog to select file in browser.

Type Definition

typescript

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

source test1.0.0

Used for function context binding.

Type Definition

typescript

function optimizeCb(
    fn: types.AnyFn,
    ctx: any,
    argCount?: number
): types.AnyFn;

ordinal

source test1.5.2

Add ordinal indicator to number.

Type Definition

typescript

function ordinal(num: number): string;

Name	Desc
num	Number to add indicator
return	Result ordinal number

javascript

ordinal(1); // -> '1st'
ordinal(2); // -> '2nd'

orientation

source test demo1.0.0

Screen orientation helper.

Type Definition

typescript

namespace orientation {
    interface IOrientation extends Emitter {
        get(): string;
    }
}
const orientation: orientation.IOrientation;

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

source test1.0.0

Pad string on the left and right sides if it's shorter than length.

Type Definition

typescript

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

source test1.0.0

Convert an object into a list of [key, value] pairs.

Type Definition

typescript

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

source test1.0.0

Run an array of functions in parallel.

Type Definition

typescript

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

source test1.0.0

Parse command line argument options, the same as minimist.

Type Definition

typescript

function parseArgs(
    args: string[],
    options: {
        names: any;
        shorthands: any;
    }
): any;

Name	Desc
args	Argument array
options	Parse options
return	Parsed result

options

Name	Desc
names	option names
shorthands	option shorthands

javascript

parseArgs(['eustia', '--output', 'util.js', '-w'], {
    names: {
        output: 'string',
        watch: 'boolean'
    },
    shorthands: {
        output: 'o',
        watch: 'w'
    }
});
// -> {remain: ['eustia'], output: 'util.js', watch: true}

parseHtml

source test1.6.0

Simple html parser.

Type Definition

typescript

function parseHtml(
    html: string,
    handlers: {
        start?: (tag: string, attrs: any, unary: boolean) => void;
        end?: (tag: string) => void;
        comment?: (text: string) => void;
        text?: (text: string) => void;
    }
): void;

Name	Desc
html	Html to parse
handler	Handlers

javascript

parseHtml('<div>licia</div>', {
    start: (tag, attrs, unary) => {},
    end: tag => {},
    comment: text => {},
    text: text => {}
});

partial

source test1.0.0

Partially apply a function by filling in given arguments.

Type Definition

typescript

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

source test1.0.0

Convert string to "pascalCase".

Type Definition

typescript

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

source test1.0.0

High resolution time up to microsecond precision.

Type Definition

typescript

function perfNow(): number;

javascript

const start = perfNow();

// Do something.

console.log(perfNow() - start);

pick

source test1.0.0

Return a filtered copy of an object.

Type Definition

typescript

function pick(
    object: any,
    filter: string | string[] | Function
): any;

Name	Desc
object	Source object
filter	Object filter
return	Filtered object

javascript

pick({ a: 1, b: 2 }, 'a'); // -> {a: 1}
pick({ a: 1, b: 2, c: 3 }, ['b', 'c']); // -> {b: 2, c: 3}
pick({ a: 1, b: 2, c: 3, d: 4 }, function(val, key) {
    return val % 2;
}); // -> {a: 1, c: 3}

pipe

source test1.23.0

Pipe all streams together.

Type Definition

typescript

import stream = require('stream');
function pipe(...streams: stream.Stream[]): void;

Name	Desc
...streams	Streams to pipe

javascript

const fs = require('fs');
const through = require('licia/through');
pipe(
    fs.createReadStream('in.txt'),
    through(function(chunk, enc, cb) {
        this.push(chunk);
        cb();
    }),
    fs.createWriteStream('out.txt')
);

pluck

source test1.0.0

Extract a list of property values.

Type Definition

typescript

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']

pointerEvent

source test1.42.0

Get the pointer event name, use touch and mouse events as a fallback if not supported.

Type Definition

typescript

function pointerEvent(type: 'down' | 'move' | 'up'): string;

Name	Desc
type	Event type, down, move or up
return	Pointer event name

javascript

pointerEvent('down'); // -> 'pointerdown' if supported

precision

source test1.0.0

Find decimal precision of a given number.

Type Definition

typescript

function precision(num: number): number;

Name	Desc
num	Number to check
return	Precision

javascript

precision(1.234); // -> 3;

prefetch

source test demo1.4.0

Fetch a given url.

Type Definition

typescript

function prefetch(url: string): Promise<void>;

Name	Desc
url	Url to prefetch

It uses <link rel=prefetch> if possible.

javascript

prefetch('https://eustia.liriliri.io/');

prefix

source test1.0.0

Add vendor prefixes to a CSS attribute.

Type Definition

typescript

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

source test1.0.0

Convert callback based functions into Promises.

Type Definition

typescript

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

source test1.0.0

Return a function that will itself return the key property of any passed-in object.

Type Definition

typescript

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

source test1.0.0

Parse and stringify url query strings.

Type Definition

typescript

const query: {
    parse(str: string): any;
    stringify(object: any): string;
};

parse

Parse a query string into an object.

Name	Desc
str	Query string
return	Query object

stringify

Stringify an object into a query string.

Name	Desc
obj	Query object
return	Query string

javascript

query.parse('foo=bar&eruda=true'); // -> {foo: 'bar', eruda: 'true'}
query.stringify({ foo: 'bar', eruda: 'true' }); // -> 'foo=bar&eruda=true'
query.parse('name=eruda&name=eustia'); // -> {name: ['eruda', 'eustia']}

quickSort

source test benchmark1.0.0

Quick sort implementation.

Type Definition

typescript

function quickSort(arr: any[], cmp?: types.AnyFn): any[];

Name	Desc
arr	Array to sort
cmp	Comparator
return	Sorted array

javascript

quickSort([2, 1]); // -> [1, 2]

raf

source test1.0.0

Shortcut for requestAnimationFrame.

Type Definition

typescript

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

source test1.0.0

Produces a random number between min and max(inclusive).

Type Definition

typescript

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

source test1.0.0

Random bytes generator.

Type Definition

typescript

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

source test demo1.12.0

Random color generator.

Type Definition

typescript

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

source test1.4.8

A tiny id generator, similar to nanoid.

Type Definition

typescript

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

source test1.0.0

Get a random item from an array.

Type Definition

typescript

function randomItem(arr: any[]): any;

Name	Desc
arr	Array to get
return	Randomly picked item

javascript

randomItem([1, 2, 3]); // -> 2

range

source test1.0.0

Create flexibly-numbered lists of integers.

Type Definition

typescript

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

source test1.1.0

RC4 symmetric encryption implementation.

Type Definition

typescript

const rc4: {
    encrypt(key: string, str: string): string;
    decrypt(key: string, str: string): string;
};

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('licia', 'Hello world'); // -> 'j9y2VpSfR3AdNN8='
rc4.decrypt('licia', 'j9y2VpSfR3AdNN8='); // -> 'Hello world'

ready

source test1.0.0

Invoke callback when dom is ready, similar to jQuery ready.

Type Definition

typescript

function ready(fn: types.AnyFn): void;

Name	Desc
fn	Callback function

javascript

ready(function() {
    // It's safe to manipulate dom here.
});

reduce

source test benchmark1.0.0

Turn a list of values into a single value.

Type Definition

typescript

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

source test1.0.0

Right-associative version of reduce.

Type Definition

typescript

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

source test1.0.0

Opposite of filter.

Type Definition

typescript

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

source test1.0.0

Remove all elements from array that predicate returns truthy for and return an array of the removed elements.

Type Definition

typescript

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

source test1.0.0

Repeat string n-times.

Type Definition

typescript

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

source test1.23.0

Replace all instance in a string.

Type Definition

typescript

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', 'licia'); // -> 'hello licia goodbye licia'

restArgs

source test1.0.0

This accumulates the arguments passed into an array, after a given index.

Type Definition

typescript

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

source test benchmark1.16.0

Reverse array without mutating it.

Type Definition

typescript

function reverse(arr: any[]): any[];

Name	Desc
arr	Array to modify
return	Reversed array

javascript

reverse([1, 2, 3]); // -> [3, 2, 1]

rgbToHsl

source test1.0.0

Convert rgb to hsl.

Type Definition

typescript

function rgbToHsl(rgb: number[]): number[];

Name	Desc
rgb	Rgb values
return	Hsl values

javascript

rgbToHsl([52, 203, 165, 0.8]); // -> [165, 59, 50, 0.8]

ric

source test1.4.0

Shortcut for requestIdleCallback.

Type Definition

typescript

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

source test1.0.0

Loop through all possible path and domain to remove cookie.

Type Definition

typescript

function rmCookie(key: string): void;

Name	Desc
key	Cookie key

javascript

rmCookie('test');

rmdir

source test1.0.0

Recursively remove directories.

Type Definition

typescript

function rmdir(dir: string, cb?: types.AnyFn): void;

Name	Desc
dir	Directory to remove
cb	Callback

javascript

rmdir('/tmp/foo/bar/baz', function(err) {
    if (err) console.log(err);
    else console.log('Done');
});

root

source test1.0.0

Root object reference, global in nodeJs, window in browser.

Type Definition

typescript

const root: any;

rpad

source test1.0.0

Pad string on the right side if it's shorter than length.

Type Definition

typescript

function rpad(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

rpad('a', 5); // -> 'a    '
rpad('a', 5, '-'); // -> 'a----'
rpad('abc', 3, '-'); // -> 'abc'
rpad('abc', 5, 'ab'); // -> 'abcab'

rtrim

source test1.0.0

Remove chars or white-spaces from end of string.

Type Definition

typescript

function rtrim(str: string, chars?: string | string[]): string;

Name	Desc
str	String to trim
chars	Characters to trim
return	Trimmed string

javascript

rtrim(' abc  '); // -> ' abc'
rtrim('_abc_', '_'); // -> '_abc'
rtrim('_abc_', ['c', '_']); // -> '_ab'

safeCb

source test1.0.0

Create callback based on input value.

Type Definition

typescript

function safeCb(
    val?: any,
    ctx?: any,
    argCount?: number
): types.AnyFn;

safeDel

source test1.0.0

Delete object property.

Type Definition

typescript

function safeDel(obj: any, path: string | string[]): any;

Name	Desc
obj	Object to query
path	Path of property to delete
return	Deleted value or undefined

javascript

const obj = { a: { aa: { aaa: 1 } } };
safeDel(obj, 'a.aa.aaa'); // -> 1
safeDel(obj, ['a', 'aa']); // -> {}
safeDel(obj, 'a.b'); // -> undefined

safeGet

source test1.0.0

Get object property, don't throw undefined error.

Type Definition

typescript

function safeGet(obj: any, path: string | string[]): any;

Name	Desc
obj	Object to query
path	Path of property to get
return	Target value or undefined

javascript

const obj = { a: { aa: { aaa: 1 } } };
safeGet(obj, 'a.aa.aaa'); // -> 1
safeGet(obj, ['a', 'aa']); // -> {aaa: 1}
safeGet(obj, 'a.b'); // -> undefined

safeSet

source test1.0.0

Set value at path of object.

Type Definition

typescript

function safeSet(
    obj: any,
    path: string | string[],
    val: any
): void;

If a portion of path doesn't exist, it's created.

Name	Desc
obj	Object to modify
path	Path of property to set
val	Value to set

javascript

const obj = {};
safeSet(obj, 'a.aa.aaa', 1); // obj = {a: {aa: {aaa: 1}}}
safeSet(obj, ['a', 'aa'], 2); // obj = {a: {aa: 2}}
safeSet(obj, 'a.b', 3); // obj = {a: {aa: 2, b: 3}}

safeStorage

source test1.0.0

Use storage safely in safari private browsing and older browsers.

Type Definition

typescript

function safeStorage(type?: string): typeof window.localStorage;

Name	Desc
type='local'	local or session
return	Specified storage

javascript

const localStorage = safeStorage('local');
localStorage.setItem('licia', 'util');

sameOrigin

source test1.26.0

Check if two urls pass the same origin policy.

Type Definition

typescript

function sameOrigin(url1: string, url2: string): boolean;

Name	Desc
url1	Url to check
url2	Url to check
return	True if urls pass same origin policy

javascript

const url1 = 'http://example.com/a.html';
const url2 = 'http://example.com/b.html';
const url3 = 'http://licia.liriliri.io';
sameOrigin(url1, url2); // -> true
sameOrigin(url1, url3); // -> false

sample

source test1.0.0

Sample random values from a collection.

Type Definition

typescript

function sample(obj: any, n: number): any[];

Name	Desc
obj	Collection to sample
n	Number of values
return	Array of sample values

javascript

sample([2, 3, 1], 2); // -> [2, 3]
sample({ a: 1, b: 2, c: 3 }, 1); // -> [2]

scrollTo

source test demo1.0.0

Scroll to a target with animation.

Type Definition

typescript

function scrollTo(
    target: Element | string | number,
    options: {
        tolerance?: number;
        duration?: number;
        easing?: string | Function;
        callback?: types.AnyFn;
    }
);

Name	Desc
target	Scroll target
options	Scroll options

options

Name	Desc
tolerance=0	Tolerance of target to scroll
duration=800	Scroll duration
easing=outQuart	Easing function
callback=noop	Function to run once scrolling complete

javascript

scrollTo('body', {
    tolerance: 0,
    duration: 800,
    easing: 'outQuart',
    callback: function() {}
});

seedRandom

source test1.12.0

Seeded random number generator.

Type Definition

typescript

function seedRandom(
    seed: number,
    min?: number,
    max?: number,
    floating?: boolean
): () => number;

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

source test1.0.0

Selection sort implementation.

Type Definition

typescript

function selectionSort(arr: any[], cmp?: types.AnyFn): any[];

Name	Desc
arr	Array to sort
cmp	Comparator
return	Sorted array

javascript

selectionSort([2, 1]); // -> [1, 2]

selector

source test1.14.0

Css selector parser and serializer.

Type Definition

typescript

namespace selector {
    interface IToken {
        type: string;
        value: string;
    }
}
const selector: {
    parse(selector: string): Array<selector.IToken[]>;
    stringify(selector: Array<selector.IToken[]>): string;
};

parse

Parse css selector into js object.

Name	Desc
selector	Css selector
return	Parsed js object

stringify

Stringify object into an css selector.

Name	Desc
groups	Object to stringify
return	Css selector

javascript

const groups = selector.parse('#test, input.user[name="licia"]');
// -> [[{type: 'id', value: 'test'}],[{type: 'tag', value: 'input'}...]]
selector.stringify(groups);

shebang

source test1.23.0

Get command from a shebang.

Type Definition

typescript

function shebang(str: string): string | void;

Name	Desc
str	String to get command
return	Shebang command

javascript

shebang('#!/usr/bin/env node'); // -> '/usr/bin/env node'
shebang('#!/bin/bash'); // -> '/bin/bash'
shebang('node'); // -> undefined

shellSort

source test1.5.0

Shell sort implementation.

Type Definition

typescript

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

source test1.0.0

Randomize the order of the elements in a given array.

Type Definition

typescript

function shuffle(arr: any[]): any[];

Name	Desc
arr	Array to randomize
return	Randomized Array

javascript

shuffle([1, 2, 3]); // -> [3, 1, 2]

size

source test1.0.0

Get size of object or length of array like object.

Type Definition

typescript

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

source test1.14.0

Get approximate size of a js object.

Type Definition

typescript

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

source test1.4.1

Resolve a promise after a specified timeout.

Type Definition

typescript

function sleep(timeout: number): Promise<void>;

Name	Desc
timeout	Sleep timeout

javascript

(async function() {
    await sleep(2000);
})();

slice

source test1.0.0

Create slice of source array or array-like object.

Type Definition

typescript

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

source test1.7.0

Slugify a string.

Type Definition

typescript

function slugify(
    str: string,
    replacement?: { [index: string]: string }
): string;

Name	Desc
str	String to slugify
replacement	Custom replacement
return	Slugified string

javascript

slugify('I ♥ pony'); // -> 'I-love-pony'
slugify('I ♥ pony', { ' ': '_' }); // -> 'I_love_pony'

snakeCase

source test1.0.0

Convert string to "snakeCase".

Type Definition

typescript

function snakeCase(str: string): string;

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

source test1.0.0

Check if predicate return truthy for any element.

Type Definition

typescript

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

source test1.0.0

Return an array of elements sorted in ascending order by results of running each element through iteratee.

Type Definition

typescript

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

source test1.17.0

Sort keys of an object.

Type Definition

typescript

function sortKeys(
    obj: object,
    options?: {
        deep?: boolean;
        comparator?: types.AnyFn;
    }
): object;

Name	Desc
obj	Object to sort
options	Sort options
return	Object with sorted keys

Available options:

Name	Desc
deep=false	Sort keys recursively
comparator	Comparator

javascript

sortKeys(
    { b: { d: 2, c: 1 }, a: 0 },
    {
        deep: true
    }
); // -> {a: 0, b: {c: 1, d: 2}}

spaceCase

source test1.0.0

Convert string to "spaceCase".

Type Definition

typescript

function spaceCase(str: string): string;

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

source test1.0.0

Split different string case to an array.

Type Definition

typescript

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

source test1.0.0

Split path into dir, name and ext.

Type Definition

typescript

function splitPath(
    path: string
): {
    dir: string;
    name: string;
    ext: string;
};

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

source test1.5.3

Get CallSite objects in v8.

Type Definition

typescript

function stackTrace(): any[];

Stack trace API

javascript

stackTrace(); // -> List of CallSite objects

startWith

source test1.0.0

Check if string starts with the given target string.

Type Definition

typescript

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

source test1.0.0

String hash function using djb2.

Type Definition

typescript

function strHash(str: string): number;

Name	Desc
str	String to hash
return	Hash result

javascript

strHash('test'); // -> 2090770981

strToBytes

source test1.1.0

Convert string into bytes.

Type Definition

typescript

function strToBytes(str: string, encoding?: string): number[];

Name	Desc
str	String to convert
encoding=utf8	Encoding of string
return	Bytes array

Supported encoding: utf8, hex, base64

javascript

strToBytes('licia'); // -> [108, 105, 99, 105, 97]
strToBytes('qK6b/w==', 'base64'); // -> [168, 174, 155, 255]

strTpl

source test1.23.0

Simple string template.

Type Definition

typescript

function strTpl(str: string, data: types.PlainObj<any>): string;

Name	Desc
str	Template string
data	Data to pass in
return	Result string

javascript

strTpl('Hello, {{name.first}}!', { name: { first: 'licia' } }); // -> 'Hello, licia!'

strWidth

source test1.24.0

Get string's visual width.

Type Definition

typescript

function strWidth(str: string): number;

Name	Desc
str	String to get width
return	Visual width

javascript

strWidth('Hello \nworld!'); // -> 12
strWidth('\u001b[4m你好，世界！\u001b[0m'); // -> 12

stringify

source test1.0.0

JSON stringify with support for circular object, function etc.

Type Definition

typescript

function stringify(obj: any, spaces?: number): string;

Undefined is treated as null value.

Name	Desc
obj	Object to stringify
spaces	Indent spaces
return	Stringified object

javascript

stringify({ a: function() {} }); // -> '{"a":"[Function function () {}]"}'
const obj = { a: 1, b: {} };
obj.b = obj;
stringify(obj); // -> '{"a":1,"b":"[Circular ~]"}'

stringifyAll

source test demo1.5.5

Stringify object into json with types.

Type Definition

typescript

namespace stringifyAll {
    function parse(str: string): any;
}
function stringifyAll(
    obj: any,
    options?: {
        unenumerable?: boolean;
        symbol?: boolean;
        accessGetter?: boolean;
        timeout?: number;
        depth?: number;
        ignore?: any[];
    }
): string;

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

source test1.0.0

Strip ansi codes from a string.

Type Definition

typescript

function stripAnsi(str: string): string;

Name	Desc
str	String to strip
return	Result string

javascript

stripAnsi('\u001b[4mcake\u001b[0m'); // -> 'cake'

stripBom

source test1.38.0

Strip UTF-8 byte order mark.

Type Definition

typescript

function stripBom(str: string): string;

Name	Desc
str	String to strip
return	Result string

javascript

stripBom('\uFEFFlicia'); // -> 'licia'

stripCmt

source test1.0.0

Strip comments from source code.

Type Definition

typescript

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

source test1.0.0

Strip ansi color codes from a string.

Type Definition

typescript

function stripColor(str: string): string;

Name	Desc
str	String to strip
return	Result string

javascript

stripColor('\u001b[31mred\u001b[39m'); // -> 'red'

stripHtmlTag

source test1.0.0

Strip html tags from a string.

Type Definition

typescript

function stripHtmlTag(str: string): string;

Name	Desc
str	String to strip
return	Result string

javascript

stripHtmlTag('<p>Hello</p>'); // -> 'Hello'

stripIndent

source test1.5.4

Strip indentation from multi-line strings.

Type Definition

typescript

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

source test1.15.0

Strip number to a specified precision.

Type Definition

typescript

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

source test1.0.0

Compute sum of given numbers.

Type Definition

typescript

function sum(...num: number[]): number;

Name	Desc
...num	Numbers to calculate
return	Sum of numbers

javascript

sum(1, 2, 5); // -> 8

swap

source test1.0.0

Swap two items in an array.

Type Definition

typescript

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

source test1.24.0

Output table string.

Type Definition

typescript

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

source test1.0.0

Compile JavaScript template into function that can be evaluated for rendering.

Type Definition

typescript

function template(str: string, util?: any): types.AnyFn;

Name	Desc
str	Template string
util	Utility functions
return	Compiled template function

javascript

template('Hello <%= name %>!')({ name: 'licia' }); // -> 'Hello licia!'
template('<p><%- name %></p>')({ name: '<licia>' }); // -> '<p>&lt;licia&gt;</p>'
template('<%if (echo) {%>Hello licia!<%}%>')({ echo: true }); // -> 'Hello licia!'
template('<p><%= util["upperCase"](name) %></p>', {
    upperCase: function(str) {
        return str.toLocaleUpperCase();
    }
})({ name: 'licia' }); // -> '<p>LICIA</p>'

throttle

source test1.0.0

Return a new throttled version of the passed function.

Type Definition

typescript

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

source test1.0.0

Tiny wrapper of stream Transform.

Type Definition

typescript

import stream = require('stream');
namespace through {
    interface ThroughConstructor extends stream.Transform {
        new (opts?: stream.DuplexOptions): stream.Transform;
        (opts?: stream.DuplexOptions): stream.Transform;
    }
    type TransformCallback = (err?: any, data?: any) => void;
    type TransformFunction = (
        this: stream.Transform,
        chunk: any,
        enc: string,
        callback: TransformCallback
    ) => void;
    type FlushCallback = (
        this: stream.Transform,
        flushCallback: () => void
    ) => void;
    function obj(
        transform?: TransformFunction,
        flush?: FlushCallback
    ): stream.Transform;
    function ctor(
        transform?: TransformFunction,
        flush?: FlushCallback
    ): ThroughConstructor;
    function ctor(
        opts?: stream.DuplexOptions,
        transform?: TransformFunction,
        flush?: FlushCallback
    ): ThroughConstructor;
}
function through(
    transform?: through.TransformFunction,
    flush?: through.FlushCallback
): stream.Transform;
function through(
    opts?: stream.DuplexOptions,
    transform?: through.TransformFunction,
    flush?: through.FlushCallback
): stream.Transform;

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'));

tildify

source test1.40.0

Convert absolute path to tilde path.

Type Definition

typescript

function tildify(path: string): string;

Name	Desc
path	Path to convert
return	Tilde path

javascript

tildify('/home/surunzi/dev'); // -> '~/dev'

timeAgo

source test1.0.0

Format datetime with *** time ago statement.

Type Definition

typescript

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

source test1.0.0

Get execution time of a function.

Type Definition

typescript

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

source test1.2.0

Invoke given function n times.

Type Definition

typescript

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

source test1.0.0

Convert value to an array.

Type Definition

typescript

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

source test1.8.0

Use generator like async/await.

Type Definition

typescript

function toAsync(fn: types.AnyFn): types.AnyFn;

Name	Desc
fn	Generator function
return	Result function

javascript

const sleep = require('licia/sleep');

const fn = toAsync(function*() {
    yield sleep(200);
    return 'licia';
});

fn().then(str => {});

toBool

source test1.0.0

Convert value to a boolean.

Type Definition

typescript

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

source test1.0.0

Convert value to a Date.

Type Definition

typescript

function toDate(val: any): Date;

Name	Desc
val	Value to convert
return	Converted Date

javascript

toDate('20180501');
toDate('2018-05-01');
toDate(1525107450849);

toEl

source test1.0.0

Convert html string to dom elements.

Type Definition

typescript

function toEl(str: string): Element;

There should be only one root element.

Name	Desc
str	Html string
return	Html element

javascript

toEl('<div>test</div>');

toInt

source test1.0.0

Convert value to an integer.

Type Definition

typescript

function toInt(val: any): number;

Name	Desc
val	Value to convert
return	Converted integer

javascript

toInt(1.1); // -> 1
toInt(undefined); // -> 0

toNum

source test1.0.0

Convert value to a number.

Type Definition

typescript

function toNum(val: any): number;

Name	Desc
val	Value to process
return	Result number

javascript

toNum('5'); // -> 5

toSrc

source test1.0.0

Convert function to its source code.

Type Definition

typescript

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

source test1.0.0

Convert value to a string.

Type Definition

typescript

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

source test1.0.0

Topological sorting algorithm.

Type Definition

typescript

function topoSort(edges: any[]): any[];

Name	Desc
edges	Dependencies
return	Sorted order

javascript

topoSort([
    [1, 2],
    [1, 3],
    [3, 2]
]); // -> [1, 3, 2]

trigger

source test1.0.0

Trigger browser events.

Type Definition

typescript

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

source test benchmark1.0.0

Remove chars or white-spaces from beginning end of string.

Type Definition

typescript

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

source test1.20.0

Truncate a string to a specific width.

Type Definition

typescript

function truncate(
    txt: string,
    width: number,
    options?: {
        ellipsis?: string;
        separator: string;
    }
): string;

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

source test1.0.0

Run function in a try catch.

Type Definition

typescript

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

source test1.0.0

Determine the internal JavaScript [[Class]] of an object.

Type Definition

typescript

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

source test1.0.0

Used for typescript definitions only.

Type Definition

typescript

namespace types {
    interface Collection<T> {}
    interface List<T> extends Collection<T> {
        [index: number]: T;
        length: number;
    }
    interface ListIterator<T, TResult> {
        (value: T, index: number, list: List<T>): TResult;
    }
    interface Dictionary<T> extends Collection<T> {
        [index: string]: T;
    }
    interface ObjectIterator<T, TResult> {
        (element: T, key: string, list: Dictionary<T>): TResult;
    }
    interface MemoIterator<T, TResult> {
        (prev: TResult, curr: T, index: number, list: List<T>): TResult;
    }
    interface MemoObjectIterator<T, TResult> {
        (prev: TResult, curr: T, key: string, list: Dictionary<T>): TResult;
    }
    type Fn<T> = (...args: any[]) => T;
    type AnyFn = Fn<any>;
    type PlainObj<T> = { [name: string]: T };
}
const types: {};

ucs2

source test1.0.0

UCS-2 encoding and decoding.

Type Definition

typescript

const ucs2: {
    encode(arr: number[]): string;
    decode(str: string): number[];
};

encode

Create a string using an array of code point values.

Name	Desc
arr	Array of code points
return	Encoded string

decode

Create an array of code point values using a string.

Name	Desc
str	Input string
return	Array of code points

javascript

ucs2.encode([0x61, 0x62, 0x63]); // -> 'abc'
ucs2.decode('abc'); // -> [0x61, 0x62, 0x63]
'𝌆'.length; // -> 2
ucs2.decode('𝌆').length; // -> 1

uncaught

source test demo1.2.0

Handle global uncaught errors and promise rejections.

Type Definition

typescript

const uncaught: {
    start(): void;
    stop(): void;
    addListener(fn: (err: Error) => void): void;
    rmListener(fn: (err: Error) => void): void;
    rmAllListeners(): void;
};

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

source test1.0.0

Convert HTML entities back, the inverse of escape.

Type Definition

typescript

function unescape(str: string): string;

Name	Desc
str	String to unescape
return	Unescaped string

javascript

unescape('You &amp; Me'); // -> 'You & Me'

union

source test1.0.0

Create an array of unique values, in order, from all given arrays.

Type Definition

typescript

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

source test1.0.0

Generate a globally-unique id.

Type Definition

typescript

function uniqId(prefix?: string): string;

Name	Desc
prefix	Id prefix
return	Globally-unique id

javascript

uniqId('eustia_'); // -> 'eustia_xxx'

unique

source test1.0.0

Create duplicate-free version of an array.

Type Definition

typescript

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

source test1.7.0

Make an async function support both promises and callbacks.

Type Definition

typescript

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('licia', (err, result) => {
    console.log(result); // -> 'licia'
});
fn('licia').then(result => {
    console.log(result); // -> 'licia'
});

unzip

source test1.0.0

Opposite of zip.

Type Definition

typescript

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

source test1.0.0

Convert string to upper case.

Type Definition

typescript

function upperCase(str: string): string;

Name	Desc
str	String to convert
return	Uppercased string

javascript

upperCase('test'); // -> 'TEST'

upperFirst

source test1.0.0

Convert the first character of string to upper case.

Type Definition

typescript

function upperFirst(str: string): string;

Name	Desc
str	String to convert
return	Converted string

javascript

upperFirst('red'); // -> Red

use

source test1.0.0

Use modules that is created by define.

Type Definition

typescript

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

source test1.0.0

UTF-8 encoding and decoding.

Type Definition

typescript

const utf8: {
    encode(str: string): string;
    decode(str: string, safe?: boolean): string;
};

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

source test benchmark1.0.0

RFC4122 version 4 compliant uuid generator.

Type Definition

typescript

function uuid(): string;

Check RFC4122 4.4 for reference.

javascript

uuid(); // -> '53ce0497-6554-49e9-8d79-347406d2a88b'

values

source test1.0.0

Create an array of the own enumerable property values of object.

Type Definition

typescript

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

source test1.0.0

Get viewport scale.

Type Definition

typescript

function viewportScale(): number;

javascript

viewportScale(); // -> 3

vlq

source test1.4.0

Variable-length quantity encoding and decoding.

Type Definition

typescript

const vlq: {
    encode(number: number | number[]): string;
    decode(string: string): number[];
};

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

source test1.4.3

Wait until function returns a truthy value.

Type Definition

typescript

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

source test1.0.0

Run an array of functions in series.

Type Definition

typescript

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

source test1.27.0

Wrap a string to a given length.

Type Definition

typescript

function wordWrap(txt: string, width: number): string;

Name	Desc
txt	Text to wrap
width	Text width
return	String wrapped at given length

javascript

wordWrap('Licia is a utility library.', 10);
// -> 'Licia is \na utility \nlibrary.'

wordsToBytes

source test1.16.0

Convert 32-bit words to bytes.

Type Definition

typescript

function wordsToBytes(words: number[]): number[];

Name	Desc
words	Word array
return	Byte array

javascript

wordsToBytes([0x12345678]); // -> [0x12, 0x34, 0x56, 0x78]

workerize

source test demo1.0.0

Move a stand-alone function to a worker thread.

Type Definition

typescript

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

source test1.0.0

Wrap the function inside a wrapper function, passing it as the first argument.

Type Definition

typescript

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 '<p>' + fn(text) + '</p>';
});
p('You & Me'); // -> '<p>You &amp; Me</p>'

wx

source test1.4.6

Promised version of mini program wx object.

Type Definition

typescript

const wx: any;

javascript

wx.getStorage('test').then(res => {
    console.log(res.data);
});

xpath

source test1.10.0

Select elements using xpath, IE is not supported.

Type Definition

typescript

function xpath(xpath: string): HTMLElement[];

Name	Desc
xpath	Xpath
return	Target elements

javascript

xpath('//html/body'); // -> [body]

zip

source test1.0.0

Merge together the values of each of the arrays with the values at the corresponding position.

Type Definition

typescript

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]]

$ ​

Available methods ​

$attr ​

remove ​

$class ​

add ​

has ​

toggle ​

remove ​

$css ​

$data ​

$event ​

$insert ​

before ​

after ​

prepend ​

append ​

$offset ​

$property ​

html ​

text ​

val ​

$remove ​

$safeEls ​

$show ​

Benchmark ​

constructor ​

run ​

all ​

Blob ​

constructor ​

BloomFilter ​

constructor ​

add ​

test ​

Caseless ​

constructor ​

getKey ​

set ​

get ​

remove ​

has ​

Channel ​

send ​

connect ​

disconnect ​

isConnected ​

destroy ​

Class ​

Color ​

constructor ​

toRgb ​

toHex ​

toHsl ​

parse ​

Delegator ​

constructor ​

method ​

getter ​

setter ​

access ​

Dispatcher ​

Emitter ​

on ​

off ​

once ​

emit ​

removeAllListeners ​

mixin ​

Enum ​

constructor ​

FileBlobStore ​

save ​

FileStore ​

constructor ​

HashTable ​

constructor ​

set ​

get ​

has ​

$

Available methods

$attr

remove

$class

add

has

toggle

remove

$css

$data

$event

$insert

before

after

prepend

append

$offset

$property

html

text

val

$remove

$safeEls

$show

Benchmark

constructor

run

all

Blob

constructor

BloomFilter

constructor

add

test

Caseless

constructor

getKey

set

get

remove

has

Channel

send

connect

disconnect

isConnected

destroy

Class

Color

constructor

toRgb

toHex

toHsl

parse

Delegator

constructor

method

getter

setter

access

Dispatcher

Emitter

on

off

once

emit

removeAllListeners

mixin

Enum

constructor

FileBlobStore

save

FileStore

constructor

HashTable

constructor

set

get

has