@wizhut_tech/wizjs 0.1.5 → 0.1.7

package/__tests__/lang_itertools.test.js

@@ -1,6 +1,6 @@
 const t = require('tap');
 
-const { count, repeat } = require('../src/lang/itertools.js');
+const { count, repeat, cycle, chain, take, zip, range, enumerate, islice, takewhile, dropwhile, filterfalse, zip_longest, product, groupby, starmap, batched, pairwise, compress } = require('../src/lang/itertools.js');
 
 
 t.test('itertools/count', (t) => {
@@ -25,7 +25,7 @@ t.test('itertools/repeat', (t) => {
     // single repeat
     const repeatGen = repeat(10, 1);
     t.equal(repeatGen.next().value, 10);
-    t.equal(repeatGen.return().done, true);
+    t.equal(repeatGen.next().done, true);
 
     // eternal repeat
     const repeatGenTwo = repeat(15, 0);
@@ -39,4 +39,211 @@ t.test('itertools/repeat', (t) => {
     t.equal(repeatGenThree.return().done, true);
 
     t.end();
-});
+});
+
+
+t.test('itertools/cycle', (t) => {
+    const cycled = cycle([1, 2, 3]);
+    t.equal(cycled.next().value, 1);
+    t.equal(cycled.next().value, 2);
+    t.equal(cycled.next().value, 3);
+    t.equal(cycled.next().value, 1);
+    t.equal(cycled.next().value, 2);
+    t.equal(cycled.next().value, 3);
+    t.equal(cycled.next().value, 1);
+    t.equal(cycled.return().done, true);
+
+    const fromGen = cycle((function* () { yield 'a'; yield 'b'; })());
+    t.equal(fromGen.next().value, 'a');
+    t.equal(fromGen.next().value, 'b');
+    t.equal(fromGen.next().value, 'a');
+    t.equal(fromGen.return().done, true);
+
+    t.equal(cycle(null).next().done, true);
+    t.equal(cycle([]).next().done, true);
+
+    t.end();
+});
+
+
+t.test('itertools/chain', (t) => {
+    t.match([...chain([1, 2], [3, 4])], [1, 2, 3, 4]);
+    t.match([...chain([1], [], [2, 3])], [1, 2, 3]);
+    t.match([...chain(null, [1], undefined, [2])], [1, 2]);
+    t.match([...chain()], []);
+
+    const gen = (function* () { yield 9; })();
+    t.match([...chain([1], gen)], [1, 9]);
+
+    t.end();
+});
+
+
+t.test('itertools/take', (t) => {
+    t.match(take(3, count(0)), [0, 1, 2]);
+    t.match(take(2, [10, 20, 30, 40]), [10, 20]);
+    t.match(take(10, [1, 2]), [1, 2]);
+    t.match(take(0, [1, 2, 3]), []);
+    t.match(take(-1, [1, 2, 3]), []);
+    t.match(take(3, null), []);
+    t.match(take(4, cycle([1, 2])), [1, 2, 1, 2]);
+    t.end();
+});
+
+
+t.test('itertools/zip', (t) => {
+    t.match([...zip([1, 2, 3], ['a', 'b', 'c'])], [[1, 'a'], [2, 'b'], [3, 'c']]);
+    t.match([...zip([1, 2, 3], ['a', 'b'])], [[1, 'a'], [2, 'b']]);
+    t.match([...zip([1], ['a'], [true, false])], [[1, 'a', true]]);
+    t.match([...zip()], []);
+    t.match([...zip(null, [1, 2])], []);
+    t.match([...zip(count(0), ['x', 'y'])], [[0, 'x'], [1, 'y']]);
+    t.end();
+});
+
+
+t.test('itertools/range', (t) => {
+    t.match([...range(5)], [0, 1, 2, 3, 4]);
+    t.match([...range(1, 5)], [1, 2, 3, 4]);
+    t.match([...range(0, 10, 2)], [0, 2, 4, 6, 8]);
+    t.match([...range(5, 0, -1)], [5, 4, 3, 2, 1]);
+    t.match([...range(0, 1, 0.5)], [0, 0.5]);
+    t.match([...range(0, 0)], []);
+    t.match([...range(-3)], []);
+    t.match([...range(0, 10, 0)], []);
+    t.match([...range()], []);
+    t.end();
+});
+
+
+t.test('itertools/enumerate', (t) => {
+    t.match([...enumerate(['a', 'b', 'c'])], [[0, 'a'], [1, 'b'], [2, 'c']]);
+    t.match([...enumerate(['a', 'b'], 10)], [[10, 'a'], [11, 'b']]);
+    t.match([...enumerate([])], []);
+    t.match([...enumerate(null)], []);
+    t.end();
+});
+
+
+t.test('itertools/islice', (t) => {
+    t.match([...islice('ABCDEFG', 2)], ['A', 'B']);
+    t.match([...islice('ABCDEFG', 2, 4)], ['C', 'D']);
+    t.match([...islice('ABCDEFG', 2, null)], ['C', 'D', 'E', 'F', 'G']);
+    t.match([...islice('ABCDEFG', 0, null, 2)], ['A', 'C', 'E', 'G']);
+    t.match([...islice('ABCDEFG', 2, 6, 2)], ['C', 'E']);
+    t.match([...islice('ABC', null, 2)], ['A', 'B']);
+    t.match([...islice('ABCD', 0, 4, null)], ['A', 'B', 'C', 'D']);
+    t.match([...islice([1, 2, 3], 0)], []);
+    t.match([...islice([1, 2, 3], 2, 2)], []);
+    t.match([...islice([1, 2, 3], 0, 3, 0)], []);
+    t.match([...islice(null, 3)], []);
+    t.end();
+});
+
+
+t.test('itertools/takewhile', (t) => {
+    t.match([...takewhile((x) => x < 5, [1, 4, 6, 4, 1])], [1, 4]);
+    t.match([...takewhile((x) => x < 0, [1, 2])], []);
+    t.match([...takewhile((x) => x < 9, [1, 2])], [1, 2]);
+    t.match([...takewhile((x) => x, null)], []);
+    t.match([...takewhile(null, [1, 2])], []);
+    t.end();
+});
+
+
+t.test('itertools/dropwhile', (t) => {
+    t.match([...dropwhile((x) => x < 5, [1, 4, 6, 4, 1])], [6, 4, 1]);
+    t.match([...dropwhile((x) => x < 0, [1, 2])], [1, 2]);
+    t.match([...dropwhile((x) => x < 9, [1, 2])], []);
+    t.match([...dropwhile((x) => x, null)], []);
+    t.match([...dropwhile(null, [1, 2])], []);
+    t.end();
+});
+
+
+t.test('itertools/filterfalse', (t) => {
+    t.match([...filterfalse((x) => x % 2, range(10))], [0, 2, 4, 6, 8]);
+    t.match([...filterfalse((x) => x, [0, 1, false, 2, ''])], [0, false, '']);
+    t.match([...filterfalse((x) => x, null)], []);
+    t.match([...filterfalse(null, [1, 2])], []);
+    t.end();
+});
+
+
+t.test('itertools/zip_longest', (t) => {
+    t.match([...zip_longest([1, 2, 3], ['a', 'b'])], [[1, 'a'], [2, 'b'], [3, undefined]]);
+    t.match([...zip_longest([1, 2], ['a', 'b', 'c'], { fillvalue: '-' })], [[1, 'a'], [2, 'b'], ['-', 'c']]);
+    t.match([...zip_longest()], []);
+    t.match([...zip_longest(null, [1])], []);
+    t.match([...zip_longest([], [1, 2], { fillvalue: 0 })], [[0, 1], [0, 2]]);
+    t.end();
+});
+
+
+t.test('itertools/product', (t) => {
+    t.match([...product()], [[]]);
+    t.match([...product('AB', [1, 2])], [['A', 1], ['A', 2], ['B', 1], ['B', 2]]);
+    t.match([...product([1, 2], [3], [4, 5])], [[1, 3, 4], [1, 3, 5], [2, 3, 4], [2, 3, 5]]);
+    t.match([...product([1, 2], [])], []);
+    t.match([...product(null, [1])], []);
+    t.end();
+});
+
+
+t.test('itertools/groupby', (t) => {
+    t.match([...groupby('AAAABBBCCDAABBB')], [
+        ['A', ['A', 'A', 'A', 'A']],
+        ['B', ['B', 'B', 'B']],
+        ['C', ['C', 'C']],
+        ['D', ['D']],
+        ['A', ['A', 'A']],
+        ['B', ['B', 'B', 'B']]
+    ]);
+    t.match([...groupby([1, 2, 3, 4], (x) => x % 2)], [
+        [1, [1]],
+        [0, [2]],
+        [1, [3]],
+        [0, [4]]
+    ]);
+    t.match([...groupby([])], []);
+    t.match([...groupby(null)], []);
+    t.match([...groupby([NaN, NaN, 1])], [[NaN, [NaN, NaN]], [1, [1]]]);
+    t.end();
+});
+
+
+t.test('itertools/starmap', (t) => {
+    t.match([...starmap(Math.pow, [[2, 5], [3, 2], [10, 3]])], [32, 9, 1000]);
+    t.match([...starmap((a, b) => a + b, zip([1, 2], [3, 4]))], [4, 6]);
+    t.match([...starmap(Math.max, null)], []);
+    t.match([...starmap(null, [[1]])], []);
+    t.end();
+});
+
+
+t.test('itertools/batched', (t) => {
+    t.match([...batched('ABCDEFG', 3)], [['A', 'B', 'C'], ['D', 'E', 'F'], ['G']]);
+    t.match([...batched([1, 2, 3], 3)], [[1, 2, 3]]);
+    t.match([...batched([1, 2, 3], 0)], []);
+    t.match([...batched(null, 2)], []);
+    t.match([...batched([], 2)], []);
+    t.end();
+});
+
+
+t.test('itertools/pairwise', (t) => {
+    t.match([...pairwise('ABCDE')], [['A', 'B'], ['B', 'C'], ['C', 'D'], ['D', 'E']]);
+    t.match([...pairwise([1])], []);
+    t.match([...pairwise([])], []);
+    t.match([...pairwise(null)], []);
+    t.end();
+});
+
+
+t.test('itertools/compress', (t) => {
+    t.match([...compress('ABCDEF', [1, 0, 1, 0, 1, 1])], ['A', 'C', 'E', 'F']);
+    t.match([...compress([1, 2, 3], [true, false])], [1]);
+    t.match([...compress(null, [1])], []);
+    t.match([...compress([1], null)], []);
+    t.end();
+});

package/__tests__/lang_objects.test.js

@@ -0,0 +1,71 @@
+const t = require('tap');
+
+const { pick, omit, get } = require('../src/lang/objects.js');
+
+
+t.test('objects/pick', (t) => {
+    t.match(pick({ a: 1, b: 2, c: 3 }, ['a', 'c']), { a: 1, c: 3 });
+    t.match(pick({ a: 1, b: 2 }, 'a'), { a: 1 });
+    t.match(pick({ a: 1 }, ['a', 'missing']), { a: 1 });
+    t.match(pick(null, ['a']), {});
+    t.match(pick(undefined, ['a']), {});
+    t.match(pick(1, ['a']), {});
+    t.match(pick({ a: 1 }, []), {});
+
+    const proto = { inherited: 1 };
+    const obj = Object.create(proto);
+    obj.own = 2;
+    t.equal(pick(obj, ['inherited']).inherited, 1);
+    t.equal(pick(obj, ['own']).own, 2);
+
+    const src = {};
+    Object.defineProperty(src, '__proto__', {
+        value: { polluted: true },
+        enumerable: true,
+        configurable: true
+    });
+    const picked = pick(src, ['__proto__']);
+    t.equal(Object.getPrototypeOf(picked), Object.prototype);
+    t.equal(picked.polluted, undefined);
+    t.equal(Object.prototype.polluted, undefined);
+
+    const withCtor = pick({ constructor: 1, prototype: 2, a: 3 }, ['constructor', 'prototype', 'a']);
+    t.equal(withCtor.constructor, 1);
+    t.equal(withCtor.prototype, 2);
+    t.equal(withCtor.a, 3);
+    t.end();
+});
+
+
+t.test('objects/omit', (t) => {
+    t.match(omit({ a: 1, b: 2, c: 3 }, ['b']), { a: 1, c: 3 });
+    t.match(omit({ a: 1, b: 2 }, 'a'), { b: 2 });
+    t.match(omit({ a: 1 }, ['missing']), { a: 1 });
+    t.match(omit(1, ['a']), {});
+    t.match(omit(true, ['a']), {});
+    t.match(omit(undefined, ['a']), {});
+    t.match(omit({ a: 1, b: 2 }, []), { a: 1, b: 2 });
+    t.match(omit({ 1: 'one', a: 2 }, [1]), { a: 2 });
+    t.end();
+});
+
+
+t.test('objects/get', (t) => {
+    const data = { a: { b: { c: 3 } }, n: null, u: undefined };
+
+    t.equal(get(data, 'a.b.c'), 3);
+    t.equal(get(data, ['a', 'b', 'c']), 3);
+    t.equal(get(data, 'a.b.missing', 'fallback'), 'fallback');
+    t.equal(get(data, 'a.missing.c', 'fallback'), 'fallback');
+    t.equal(get(data, 'n'), null);
+    t.equal(get({ a: 'hello' }, 'a.x', 'fallback'), 'fallback');
+    t.equal(get({ a: 1 }, 'a.b', 'fallback'), 'fallback');
+    t.equal(get(data, 'u', 'fallback'), 'fallback');
+    t.equal(get(null, 'a', 'fallback'), 'fallback');
+    t.equal(get(undefined, 'a', 'fallback'), 'fallback');
+    t.equal(get(data, ''), data);
+    t.equal(get(data, []), data);
+    t.equal(get(['x', 'y'], 1), 'y');
+    t.equal(get(data, 'a.b'), data.a.b);
+    t.end();
+});

package/__tests__/math_numbers.test.js

@@ -1,6 +1,6 @@
 const t = require('tap');
 
-const { toInteger } = require('../src/math/numbers.js');
+const { toInteger, toNumber, clamp, mod } = require('../src/math/numbers.js');
 
 
 t.test('numbers/toInteger', (t) => {
@@ -14,3 +14,42 @@ t.test('numbers/toInteger', (t) => {
     t.equal(toInteger(Symbol('x')), 0);
     t.end();
 });
+
+
+t.test('numbers/toNumber', (t) => {
+    t.equal(toNumber(null), 0);
+    t.equal(toNumber(undefined), 0);
+    t.equal(toNumber(1.5), 1.5);
+    t.equal(toNumber('1.5'), 1.5);
+    t.equal(toNumber('1.5abc'), 1.5);
+    t.equal(toNumber(1), 1);
+    t.equal(toNumber('abcde'), 0);
+    t.equal(toNumber(Symbol('x')), 0);
+    t.end();
+});
+
+
+t.test('numbers/clamp', (t) => {
+    t.equal(clamp(5, 0, 10), 5);
+    t.equal(clamp(-1, 0, 10), 0);
+    t.equal(clamp(11, 0, 10), 10);
+    t.equal(clamp(5, 10, 0), 5);
+    t.equal(clamp(-3, 10, 0), 0);
+    t.equal(clamp(0, 0, 0), 0);
+    t.ok(Number.isNaN(clamp(undefined, 0, 10)));
+    t.end();
+});
+
+
+t.test('numbers/mod', (t) => {
+    t.equal(mod(5, 3), 2);
+    t.equal(mod(-1, 5), 4);
+    t.equal(mod(-5, 3), 1);
+    t.equal(mod(5, -3), -1);
+    t.equal(mod(0, 3), 0);
+    t.equal(mod(5, 0), 0);
+    t.equal(mod(null, 3), 0);
+    t.equal(mod(5, null), 0);
+    t.equal(mod(NaN, 3), 0);
+    t.end();
+});

package/docs/lang_arrays.md

@@ -2,7 +2,10 @@
 
 * **compact(arg)**: removes *null* and *undefined* values from an array, returns always an array. If the *arg* is invalid, it returns an empty array.
 * **accumulate(operator, a, b)**: applies the operator to *a* and *b* then returns the result.
+* **unique(arr)**: returns a new array with duplicate values removed, preserving first-seen order. Uses `SameValueZero` equality (so `NaN` matches `NaN`). If *arr* is `null`/`undefined`, returns an empty array.
+* **chunk(arr, size)**: splits *arr* into arrays of length *size*. The last chunk may be shorter. If *arr* is `null`/`undefined` or *size* is less than `1`, returns an empty array.
+* **flatten(arr)**: flattens *arr* by one level. Nested non-arrays are left as-is. If *arr* is `null`/`undefined`, returns an empty array.
 
 ## Classes
 
-* **Operator**: Static class that configures *accumulate* method. Support *addition (Operator.plus)*, *subtraction (Operator.minus)*, *multiplication (Operator.multiply)* and *division (Operator.division)*. 
+* **Operator**: Static class that configures *accumulate* method. Support *addition (Operator.plus)*, *subtraction (Operator.minus)*, *multiplication (Operator.multiply)* and *division (Operator.division)*. 

package/docs/lang_checks.md

@@ -5,3 +5,7 @@
 * **isObject(arg)**: Checks if the `arg` is an `object` and return `true` else `false`
 * **isString(arg)**: Checks if the `arg` is a `string` and return `true` else `false`
 * **isNumber(arg)**: Checks if the `arg` is a `number` and return `true` else `false`
+* **isBoolean(arg)**: Checks if the `arg` is a `boolean` and return `true` else `false`
+* **isFunction(arg)**: Checks if the `arg` is a `function` (including async functions, generators, and classes) and return `true` else `false`
+* **isInteger(arg)**: Checks if the `arg` is an integer number (`Number.isInteger`) and return `true` else `false`. `NaN`, `Infinity` and floats return `false`.
+* **isEmpty(arg)**: Returns `true` for `null`/`undefined`, empty strings, empty arrays, empty `Map`/`Set`, and objects with no own enumerable keys. Numbers, booleans and functions are never empty.

package/docs/lang_collections.md

@@ -0,0 +1,24 @@
+# Lang / collections
+
+Python `collections` types that JS is missing.
+
+## Counter
+
+Count hashable items. Keys use `Map` equality (`SameValueZero`), so objects and `NaN` work.
+
+* **new Counter(source)**: *source* may be an iterable (each item counted once per occurrence — `new Counter('aab')` has `a: 2`), a plain object of counts (`{ a: 2 }`), a `Map`, another `Counter`, or omitted for an empty counter.
+* **get(item)**: count of *item*, or `0` if unseen (does not insert — Python `Counter.__missing__`).
+* **add(item, n=1)**: add *n* to the count; returns the new count.
+* **set(item, n)**: set the count; returns the counter.
+* **delete(item)**: drop *item*.
+* **mostCommon(n)**: `[item, count]` pairs, highest count first. Omit *n* for every item. Ties keep insertion order.
+* **total()**: sum of counts (Python 3.10 `Counter.total`).
+* **elements()**: generator that yields each item as many times as its positive count (Python `Counter.elements`).
+* **keys() / values() / entries() / size**: `Map`-like views. The counter itself is iterable over keys (`for (const k of counter)`).
+
+## DefaultDict
+
+* **new DefaultDict(factory)**: *factory* is called to fill missing keys (Python `collections.defaultdict`). `new DefaultDict(Array)` / `new DefaultDict(() => [])` are the usual list-of-groups pattern.
+* **get(key)**: like Python `d[key]` — inserts `factory()` if missing, then returns the value. If *factory* is not a function, missing keys return `undefined` and are not inserted.
+* **peek(key, defaultValue)**: like Python `dict.get` — does **not** insert.
+* **set(key, value)** / **has(key)** / **delete(key)** / **size** / **keys()** / **values()** / **entries()**.

package/docs/lang_functools.md

@@ -1,3 +1,10 @@
 ## lang / functools
 
-* **reflexive(arg)**: Just a dumb method that returns `arg` as provided.
+Python `functools`, plus a couple of everyday function helpers.
+
+* **reflexive(arg)**: Just a dumb method that returns `arg` as provided. (Python identity: `lambda x: x`.)
+* **partial(fn, ...args)**: Returns a function that invokes *fn* with *args* prepended to whatever arguments it later receives. Preserves `this`. (Python `functools.partial`.)
+* **compose(...fns)**: Right-to-left function composition. `compose(f, g, h)(x)` is `f(g(h(x)))`. With no functions, returns `reflexive`.
+* **once(fn)**: Returns a function that invokes *fn* at most once. Later calls return the first result (including `undefined` if the first call threw after being marked as called).
+* **memoize(fn, resolver)** / **cache(fn, resolver)**: Returns a function that caches *fn* results (`cache` is the Python `functools.cache` name). With no *resolver*, arguments are compared with `SameValueZero` in a nested `Map` (so `memoize(fn)(1, 2)` and `memoize(fn)(1, 2, undefined)` are distinct, and `NaN` is a valid key). With a *resolver*, the cache key is `resolver(...args)`. Failed calls are not cached. The cache is exposed as `.cache` (`Map`); call `.cache.clear()` to drop entries.
+* **reduce(fn, iterable, initializer)**: Fold *iterable* left-to-right with *fn* (Python `functools.reduce`). If *initializer* is omitted, the first item is the start value. An empty iterable with no initializer throws `TypeError`.

package/docs/lang_itertools.md

@@ -1,4 +1,23 @@
 # Lang / itertools
 
+Python `itertools` (plus a few builtins that belong with it: `zip`, `range`, `enumerate`) as lazy generators.
+
 * **count(start, step=1)**: A generator that counts from *start* with a specified *step*. Default stepping is *1*.
-* **repeat(arg, times=0)**: A generator that repeats *arg* for *times* times. If times is 0 then it returns *arg* forever.
+* **repeat(arg, times=0)**: A generator that repeats *arg* for *times* times. If times is 0 then it returns *arg* forever.
+* **cycle(iterable)**: A generator that cycles through *iterable* forever. Values are buffered on the first pass so the source is consumed only once. Empty or `null`/`undefined` iterables yield nothing.
+* **chain(...iterables)**: A generator that yields the items of each iterable in order. `null`/`undefined` arguments are skipped.
+* **take(n, iterable)**: Consumes the first *n* items from *iterable* and returns them as an array. Stops early if the iterable is exhausted. If *n* is less than `1` or *iterable* is `null`/`undefined`, returns an empty array.
+* **zip(...iterables)**: A generator that yields arrays of aligned items, stopping when the shortest iterable is exhausted (Python `zip`). Returns an empty generator if called with no arguments or if any argument is not iterable.
+* **range(start, stop, step=1)**: A generator of numbers with an exclusive end, matching Python `range`. `range(stop)` counts from `0`. `range(start, stop)` and `range(start, stop, step)` are also supported, including negative steps. A non-finite bound or a `0` step yields nothing. The index form `start + i * step` is used so float steps do not accumulate rounding error.
+* **enumerate(iterable, start=0)**: A generator that yields `[index, value]` pairs, starting at *start* (Python `enumerate`). `null`/`undefined` iterables yield nothing.
+* **islice(iterable, stop)** / **islice(iterable, start, stop, step=1)**: Slice an iterator (Python `itertools.islice`). Negative indices are not supported. `stop` of `null` means "until exhausted". A `step` less than `1` yields nothing.
+* **takewhile(predicate, iterable)**: Yield items as long as *predicate* is truthy, then stop (Python `itertools.takewhile`).
+* **dropwhile(predicate, iterable)**: Skip items as long as *predicate* is truthy, then yield the rest (Python `itertools.dropwhile`).
+* **filterfalse(predicate, iterable)**: Yield items for which *predicate* is falsy (Python `itertools.filterfalse`).
+* **zip_longest(...iterables, { fillvalue })**: Like `zip`, but continues until the longest iterable is exhausted. Missing values are *fillvalue* (default `undefined`). Pass `{ fillvalue }` as the last argument (Python `itertools.zip_longest`).
+* **product(...iterables)**: Cartesian product. `product()` with no arguments yields one empty array, matching Python. An empty input iterable yields nothing.
+* **groupby(iterable, key)**: Consecutive grouping (Python `itertools.groupby`): a new group starts only when the key *changes*, so the input is not sorted. Each yield is `[key, items]` where *items* is an array (consumed immediately, unlike Python's shared group iterator). Without *key*, the item itself is the key. Equality is `SameValueZero`.
+* **starmap(fn, iterable)**: `fn(...args)` for each argument array in *iterable* (Python `itertools.starmap`).
+* **batched(iterable, n)**: Yield arrays of length *n*; the last batch may be shorter (Python 3.12 `itertools.batched`). *n* less than `1` yields nothing.
+* **pairwise(iterable)**: Overlapping pairs `(s0, s1), (s1, s2), ...` (Python 3.10 `itertools.pairwise`).
+* **compress(data, selectors)**: Yield items from *data* whose matching *selector* is truthy (Python `itertools.compress`). Stops when either input is exhausted.

package/docs/lang_objects.md

@@ -0,0 +1,5 @@
+# Lang / Objects
+
+* **pick(obj, keys)**: returns a new object with only the listed *keys* (an array, or a single key). Missing keys are skipped. If *obj* is `null`/`undefined` or not an object, returns `{}`. Assignments of `__proto__` / `prototype` / `constructor` use `defineProperty` so the result is not prototype-polluted.
+* **omit(obj, keys)**: returns a new object with the listed *keys* removed. If *obj* is `null`/`undefined` or not an object, returns `{}`.
+* **get(obj, path, defaultValue)**: reads a nested value. *path* may be a dotted string (`'a.b.c'`), an array of keys (`['a', 'b', 'c']`), or a single key. If any step is missing, or the resolved value is `undefined`, returns *defaultValue*. An existing `null` is returned as `null`, not as the default. If *path* is an empty string or empty array, returns *obj* itself.

package/docs/math_numbers.md

@@ -1,3 +1,6 @@
 # Math / Numbers
 
-* **toInteger(arg)**: Attempts to convert `arg` to `Integer`. Return `0` if the arg is `zero` or invalid value.
+* **toInteger(arg)**: Attempts to convert `arg` to `Integer`. Return `0` if the arg is `zero` or invalid value.
+* **toNumber(arg)**: Attempts to convert `arg` to a number via `parseFloat`. Return `0` if the arg is `null`/`undefined` or not numeric. Unlike `toInteger`, fractional values are kept (`toNumber('1.5')` is `1.5`).
+* **clamp(value, min, max)**: Constrains *value* to the inclusive range `[*min*, *max*]`. If *min* is greater than *max*, the bounds are swapped. Non-numeric *value* yields `NaN` (the same as `Number(value)`).
+* **mod(n, m)**: Mathematical modulo whose sign follows the divisor (Python `%` / floored division). `mod(-1, 5)` is `4`; JavaScript's `%` would return `-1`. Return `0` if either argument is not finite or if *m* is `0`.

package/index.js

@@ -6,6 +6,8 @@ const arrays = require('./src/lang/arrays.js');
 const files = require('./src/io/files.js');
 const flow = require('./src/lang/flow.js');
 const itertools = require('./src/lang/itertools.js');
+const objects = require('./src/lang/objects.js');
+const collections = require('./src/lang/collections.js');
 
 const { BadlyInitializedError } = require('./src/internal/exceptions.js');
 
@@ -20,7 +22,9 @@ module.exports = {
         flow: flow,
         checks: checks,
         functools: functools,
-        itertools: itertools
+        itertools: itertools,
+        objects: objects,
+        collections: collections
     },
     math: {
         numbers: numbers

package/package.json

@@ -5,7 +5,7 @@
   },
   "description": "Simple but useful hacks for everyday javascript programming",
   "devDependencies": {
-    "tap": "21.7.4"
+    "tap": "21.7.5"
   },
   "homepage": "https://github.com/wizhut/wizjs#readme",
   "keywords": [
@@ -24,5 +24,5 @@
   "scripts": {
     "test": "tap run"
   },
-  "version": "0.1.5"
+  "version": "0.1.7"
 }

package/readme.md

@@ -1,6 +1,6 @@
 # Wizjs
 
-A Javascript library (a few selected dependencies only) that contains utilities for enjoy-full every day programming. No, this library will not become another `lodash` :).
+A Javascript library that ports selected Python idioms and stdlib helpers (`itertools`, `functools`, `collections`) to everyday JS. A few selected dependencies only. No, this library will not become another `lodash` :).
 
 Use by importing:
 
@@ -17,7 +17,9 @@ Use by importing:
         flow: [functions],
         singleton: [functions],
         functools: [functions],
-        itertools: [functions]
+        itertools: [functions],
+        objects: [functions],
+        collections: [functions]
     },
     math: {
         numbers: [functions]
@@ -40,6 +42,8 @@ You can also import individual functions like the following snippet:
 * Control-**Flow** utilities ... [[docs](docs/lang_flow.md)]
 * **functools** ... [[docs](docs/lang_functools.md)]
 * **itertools** ... [[docs](docs/lang_itertools.md)]
+* **Objects** utility functions ... [[docs](docs/lang_objects.md)]
+* **collections** (`Counter`, `DefaultDict`) ... [[docs](docs/lang_collections.md)]
 * **Singleton** hack ... [[docs](docs/lang_singleton.md)]
 
 ### Math

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
+}