@wizhut_tech/wizjs 0.1.5 → 0.2.0

package/src/lang/arrays.js

@@ -1,4 +1,5 @@
-const { isNil } = require('./checks.js');
+const { isNil, isArray } = require('./checks.js');
+const { toInteger } = require('../math/numbers.js');
 
 
 function compact(arr) {
@@ -42,8 +43,78 @@ function accumulate(arr, operator, initial=0) {
 }
 
 
+function unique(arr) {
+    if (isNil(arr)) {
+        return [];
+    }
+
+    const seen = new Set();
+    const result = [];
+
+    for (let i = 0; i < arr.length; i++) {
+        const value = arr[i];
+
+        if (seen.has(value)) {
+            continue;
+        }
+
+        seen.add(value);
+        result.push(value);
+    }
+
+    return result;
+}
+
+
+function chunk(arr, size) {
+    if (isNil(arr)) {
+        return [];
+    }
+
+    const n = toInteger(size);
+
+    if (n < 1) {
+        return [];
+    }
+
+    const result = [];
+
+    for (let i = 0; i < arr.length; i += n) {
+        result.push(Array.prototype.slice.call(arr, i, i + n));
+    }
+
+    return result;
+}
+
+
+function flatten(arr) {
+    if (isNil(arr)) {
+        return [];
+    }
+
+    const result = [];
+
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+
+        if (isArray(item)) {
+            for (let j = 0; j < item.length; j++) {
+                result.push(item[j]);
+            }
+        } else {
+            result.push(item);
+        }
+    }
+
+    return result;
+}
+
+
 module.exports = {
     compact,
     accumulate,
-    Operator
-}
+    Operator,
+    unique,
+    chunk,
+    flatten
+}

package/src/lang/checks.js

@@ -30,10 +30,50 @@ function isNumber(value) {
 }
 
 
+function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+
+
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+
+function isInteger(value) {
+    return Number.isInteger(value);
+}
+
+
+function isEmpty(value) {
+    if (isNil(value)) {
+        return true;
+    }
+
+    if (isString(value) || isArray(value)) {
+        return value.length === 0;
+    }
+
+    if (value instanceof Map || value instanceof Set) {
+        return value.size === 0;
+    }
+
+    if (isObject(value)) {
+        return Object.keys(value).length === 0;
+    }
+
+    return false;
+}
+
+
 module.exports = {
     isNil,
     isArray,
     isObject,
     isString,
-    isNumber
-}
+    isNumber,
+    isBoolean,
+    isFunction,
+    isInteger,
+    isEmpty
+}

package/src/lang/collections.js

@@ -0,0 +1,191 @@
+const { isNil, isObject, isFunction } = require('./checks.js');
+const { toInteger } = require('../math/numbers.js');
+
+
+class Counter {
+    constructor(source) {
+        this._map = new Map();
+
+        if (isNil(source)) {
+            return;
+        }
+
+        if (source instanceof Counter) {
+            for (const [item, n] of source.entries()) {
+                this._map.set(item, n);
+            }
+            return;
+        }
+
+        if (source instanceof Map) {
+            for (const [item, n] of source) {
+                this.add(item, n);
+            }
+            return;
+        }
+
+        if (typeof source[Symbol.iterator] === 'function') {
+            for (const item of source) {
+                this.add(item, 1);
+            }
+            return;
+        }
+
+        if (isObject(source)) {
+            const keys = Object.keys(source);
+
+            for (let i = 0; i < keys.length; i++) {
+                this.add(keys[i], source[keys[i]]);
+            }
+        }
+    }
+
+    add(item, n) {
+        const delta = n === undefined ? 1 : Number(n);
+        const next = (this._map.has(item) ? this._map.get(item) : 0) + delta;
+        this._map.set(item, next);
+        return next;
+    }
+
+    get(item) {
+        if (!this._map.has(item)) {
+            return 0;
+        }
+
+        return this._map.get(item);
+    }
+
+    set(item, n) {
+        this._map.set(item, Number(n));
+        return this;
+    }
+
+    delete(item) {
+        return this._map.delete(item);
+    }
+
+    mostCommon(n) {
+        const entries = [];
+
+        for (const pair of this._map.entries()) {
+            entries.push(pair);
+        }
+
+        entries.sort((a, b) => b[1] - a[1]);
+
+        if (n === undefined || n === null) {
+            return entries;
+        }
+
+        const count = toInteger(n);
+
+        if (count < 1) {
+            return [];
+        }
+
+        return entries.slice(0, count);
+    }
+
+    total() {
+        let sum = 0;
+
+        for (const v of this._map.values()) {
+            sum += v;
+        }
+
+        return sum;
+    }
+
+    get size() {
+        return this._map.size;
+    }
+
+    entries() {
+        return this._map.entries();
+    }
+
+    keys() {
+        return this._map.keys();
+    }
+
+    values() {
+        return this._map.values();
+    }
+
+    *elements() {
+        for (const [item, count] of this._map) {
+            const times = count > 0 ? toInteger(count) : 0;
+
+            for (let i = 0; i < times; i++) {
+                yield item;
+            }
+        }
+    }
+
+    [Symbol.iterator]() {
+        return this._map.keys();
+    }
+}
+
+
+class DefaultDict {
+    constructor(factory) {
+        this._factory = isFunction(factory) ? factory : null;
+        this._data = new Map();
+    }
+
+    get(key) {
+        if (!this._data.has(key)) {
+            if (this._factory === null) {
+                return undefined;
+            }
+
+            this._data.set(key, this._factory());
+        }
+
+        return this._data.get(key);
+    }
+
+    peek(key, defaultValue) {
+        if (!this._data.has(key)) {
+            return defaultValue;
+        }
+
+        return this._data.get(key);
+    }
+
+    set(key, value) {
+        this._data.set(key, value);
+        return this;
+    }
+
+    has(key) {
+        return this._data.has(key);
+    }
+
+    delete(key) {
+        return this._data.delete(key);
+    }
+
+    get size() {
+        return this._data.size;
+    }
+
+    entries() {
+        return this._data.entries();
+    }
+
+    keys() {
+        return this._data.keys();
+    }
+
+    values() {
+        return this._data.values();
+    }
+}
+
+
+module.exports = {
+    Counter,
+    DefaultDict
+};

package/src/lang/functools.js

@@ -1,10 +1,143 @@
 
+const { isNil, isFunction } = require('./checks.js');
+
 
 function reflexive(arg) {
     return arg;
 }
 
 
+function partial(fn, ...preset) {
+    return function partiallyApplied(...rest) {
+        return fn.apply(this, preset.concat(rest));
+    };
+}
+
+
+function compose(...fns) {
+    if (fns.length === 0) {
+        return reflexive;
+    }
+
+    return function composed(...args) {
+        let result = fns[fns.length - 1].apply(this, args);
+
+        for (let i = fns.length - 2; i >= 0; i--) {
+            result = fns[i].call(this, result);
+        }
+
+        return result;
+    };
+}
+
+
+function once(fn) {
+    let called = false;
+    let result;
+
+    return function onceWrapped(...args) {
+        if (called) {
+            return result;
+        }
+
+        called = true;
+        result = fn.apply(this, args);
+        return result;
+    };
+}
+
+
+const MEMO_RESULT = Symbol('memoize.result');
+
+
+function memoize(fn, resolver) {
+    const cache = new Map();
+
+    const memoized = function memoized(...args) {
+        if (resolver) {
+            const key = resolver.apply(this, args);
+
+            if (cache.has(key)) {
+                return cache.get(key);
+            }
+
+            const result = fn.apply(this, args);
+            cache.set(key, result);
+            return result;
+        }
+
+        let node = cache;
+
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+
+            if (!node.has(arg)) {
+                node.set(arg, new Map());
+            }
+
+            node = node.get(arg);
+        }
+
+        if (node.has(MEMO_RESULT)) {
+            return node.get(MEMO_RESULT);
+        }
+
+        const result = fn.apply(this, args);
+        node.set(MEMO_RESULT, result);
+        return result;
+    };
+
+    memoized.cache = cache;
+    return memoized;
+}
+
+
+function reduce(fn, iterable, initializer) {
+    if (!isFunction(fn) || isNil(iterable) || typeof iterable[Symbol.iterator] !== 'function') {
+        if (arguments.length >= 3) {
+            return initializer;
+        }
+
+        throw new TypeError('reduce() of empty iterable with no initial value');
+    }
+
+    const iterator = iterable[Symbol.iterator]();
+    let acc;
+    let started = arguments.length >= 3;
+
+    if (started) {
+        acc = initializer;
+    }
+
+    while (true) {
+        const next = iterator.next();
+
+        if (next.done) {
+            break;
+        }
+
+        if (!started) {
+            acc = next.value;
+            started = true;
+        } else {
+            acc = fn(acc, next.value);
+        }
+    }
+
+    if (!started) {
+        throw new TypeError('reduce() of empty iterable with no initial value');
+    }
+
+    return acc;
+}
+
+
 module.exports = {
-    reflexive
-}
+    reflexive,
+    partial,
+    compose,
+    once,
+    memoize,
+    cache: memoize,
+    reduce
+}