@gkucmierz/utils 1.28.3 → 1.28.8

package/scripts/generate_main.mjs

@@ -1,43 +0,0 @@
-
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const MAIN_FILE = './main.mjs';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname([path.dirname(__filename), '/../src/.'].join(''));
-
-const files = fs.readdirSync(__dirname);
-
-const utilsFiles = files
-  .filter(name => name.match(/\.mjs$/))
-  .filter(name => name !== 'main.mjs');
-
-const allMethods = {};
-const map = new Map();
-
-for (const file of utilsFiles) {
-  const f = [__dirname, file].join('/');
-  const obj = await import(f);
-  map.set(file, Object.keys(obj));
-  Object.keys(obj).map(key => {
-    if (key in allMethods) throw Error('Duplicate method name');
-    allMethods[key] = obj[key];
-  });
-};
-
-fs.writeFileSync(MAIN_FILE, [
-  '',
-  ...[...map].map(([file, methods]) => {
-    return `import {\n  ${methods.join(', ')}\n} from './src/${file}'`;
-  }),
-  '',
-  ...utilsFiles.map(file => `export * from './src/${file}';`),
-  '',
-  `export default [`,
-  `  ${Object.keys(allMethods).join(', ')}`,
-  `];`,
-  '',
-].join('\n'));
-

package/spec/SetCnt.spec.mjs

@@ -1,58 +0,0 @@
-
-import {
-  SetCnt,
-} from '../src/SetCnt.mjs';
-
-const set = new Set([1,2,3,5])
-const map = new Map([[1,2],[3,5]])
-// console.log([...sc.entries()]);
-
-describe('SetCnt', () => {
-  it('has', () => {
-    const sc = new SetCnt([1,2,5,6,1,1]);
-    expect(sc.has(1)).toBe(true);
-    expect(sc.has(2)).toBe(true);
-    expect(sc.has(5)).toBe(true);
-  });
-
-  it('add', () => {
-    const sc = new SetCnt([1,2,5,6,1,1]);
-    expect(sc.add(123)).toBe(sc);
-    expect(sc.has(123)).toBe(true);
-  });
-
-  it('delete', () => {
-    const sc = new SetCnt();
-    expect(sc.add(123)).toBe(sc);
-    expect(sc.add(123)).toBe(sc);
-
-    expect(sc.delete(123)).toBe(true);
-    expect(sc.has(123)).toBe(true);
-
-    expect(sc.delete(123)).toBe(true);
-    expect(sc.has(123)).toBe(false);
-
-    expect(sc.delete(123)).toBe(false);
-  });
-
-  it('deleteAll', () => {
-    const sc = new SetCnt();
-    expect(sc.add(123)).toBe(sc);
-    expect(sc.add(123)).toBe(sc);
-
-    expect(sc.deleteAll(123)).toBe(true);
-    expect(sc.has(123)).toBe(false);
-  });
-
-  it('cnt', () => {
-    const sc = new SetCnt();
-    expect(sc.cnt(123)).toBe(0);
-
-    expect(sc.add(123)).toBe(sc);
-    expect(sc.add(123)).toBe(sc);
-
-    expect(sc.cnt(123)).toBe(2);
-    expect(sc.deleteAll(123)).toBe(true);
-    expect(sc.cnt(123)).toBe(0);
-  });
-});

package/spec/Trie.spec.mjs

@@ -1,69 +0,0 @@
-
-import {
-  Trie,
-} from '../src/Trie.mjs';
-
-describe('Trie', () => {
-  it('check empty', () => {
-    const trie = Trie();
-    expect(trie.has('')).toBe(false);
-    expect(trie.has('abc')).toBe(false);
-  });
-
-  it('init data', () => {
-    const trie = Trie(['abc', '']);
-    expect(trie.has('')).toBe(true);
-    expect(trie.has('abc')).toBe(true);
-  });
-
-  it('add/readd data', () => {
-    const trie = Trie();
-    expect(trie.has('')).toBe(false);
-    expect(trie.add('')).toBe(true);
-    expect(trie.has('')).toBe(true);
-    expect(trie.add('')).toBe(false);
-  });
-
-  it('list data', () => {
-    const trie = Trie(['abc', '', 'abcdef', 'xyz']);
-    const abc = ['abc', 'abcdef'];
-    expect(trie.get('a')).toEqual(abc);
-    expect(trie.get('ab')).toEqual(abc);
-    expect(trie.get('abc')).toEqual(abc);
-    expect(trie.get('aa')).toEqual([]);
-    expect(trie.get('')).toEqual(['', 'abc', 'abcdef', 'xyz']);
-  });
-
-  it('remove node', () => {
-    const trie = Trie(['a', 'ab', 'abc']);
-    
-    expect(trie.has('abc')).toEqual(true);
-    expect(trie.remove('abc')).toEqual(true);
-    expect(trie.remove('abc')).toEqual(false);
-    expect(trie.has('abc')).toEqual(false);
-
-    expect(trie.has('ab')).toEqual(true);
-    expect(trie.remove('ab')).toEqual(true);
-    expect(trie.remove('ab')).toEqual(false);
-    expect(trie.has('ab')).toEqual(false);
-
-    expect(trie.has('a')).toEqual(true);
-    expect(trie.remove('a')).toEqual(true);
-    expect(trie.remove('a')).toEqual(false);
-    expect(trie.has('a')).toEqual(false);
-  });
-
-  it('keep child node after parent removal', () => {
-    const trie = Trie(['a', 'abc']);
-
-    expect(trie.has('a')).toEqual(true);
-    expect(trie.remove('a')).toEqual(true);
-    expect(trie.remove('a')).toEqual(false);
-    expect(trie.has('a')).toEqual(false);
-
-    expect(trie.has('abc')).toEqual(true);
-    expect(trie.remove('abc')).toEqual(true);
-    expect(trie.remove('abc')).toEqual(false);
-    expect(trie.has('abc')).toEqual(false);
-  })
-});

package/spec/base64.spec.mjs

@@ -1,29 +0,0 @@
-
-import {
-  toBase64,
-  fromBase64,
-  toBase64Url,
-  fromBase64Url,
-} from '../src/base64.mjs';
-
-describe('base64', () => {
-  it('toBase64', () => {
-    expect(toBase64('🥚')).toBe('Ptha3Q==');
-    expect(toBase64('🐔')).toBe('PdgU3A==');
-    expect(toBase64('')).toBe('++8=');
-  });
-
-  it('fromBase64', () => {
-    expect(fromBase64('Ptha3Q==')).toBe('🥚');
-    expect(fromBase64('PdgU3A==')).toBe('🐔');
-    expect(fromBase64('++8=')).toBe('');
-  });
-
-  it('toBase64Url', () => {
-    expect(toBase64Url('')).toBe('--8=');
-  });
-
-  it('fromBase64', () => {
-    expect(fromBase64Url('--8=')).toBe('');
-  });
-});

package/spec/bijective-numeration.spec.mjs

@@ -1,123 +0,0 @@
-
-import {
-  num2bijective,
-  bijective2num,
-  num2bijectiveBI,
-  bijective2numBI,
-} from '../src/bijective-numeration.mjs';
-
-describe('bijective-numeration', () => {
-  const alpha = 'abcdefghijklmnopqrstuvwxyz';
-
-  const map = [
-    [0,    ''],
-    [1,   '1'],
-    [2,   '2'],
-    [3,  '11'],
-    [4,  '12'],
-    [5,  '21'],
-    [6,  '22'],
-    [7, '111'],
-  ];
-
-  const mapAlpha = [
-    [0, ''],
-    [1, 'a'],
-    [26, 'z'],
-    [26 + 1, 'aa'],
-    [26 * 26 + 26, 'zz'],
-    [26 * 26 + 26 + 1, 'aaa'],
-  ];
-
-  it('num2bijective', () => {
-    map.map(([num, bij]) => {
-      expect(num2bijective(num)).toEqual(bij);
-    });
-  });
-
-  it('num2bijective alpha', () => {
-    mapAlpha.map(([num, bij]) => {
-      expect(num2bijective(num, alpha)).toEqual(bij);
-    });
-  });
-
-  it('bijective2num', () => {
-    map.map(([num, bij]) => {
-      expect(bijective2num(bij)).toEqual(num);
-    });
-  });
-
-  it('bijective2num alpha', () => {
-    mapAlpha.map(([num, bij]) => {
-      expect(bijective2num(bij, alpha)).toEqual(num);
-    });
-  });
-
-  it('random tests', () => {
-    for (let i = 0; i < 1e3; ++i) {
-      const n = Math.round(Math.random() * 1e6);
-      const bj = num2bijective(n, alpha);
-      expect(bijective2num(bj, alpha)).toEqual(n);
-    }
-  });
-});
-
-describe('bijective-numeration BigInt', () => {
-  const alpha = 'abcdefghijklmnopqrstuvwxyz';
-
-  const map = [
-    [0n,    ''],
-    [1n,   '1'],
-    [2n,   '2'],
-    [3n,  '11'],
-    [4n,  '12'],
-    [5n,  '21'],
-    [6n,  '22'],
-    [7n, '111'],
-  ];
-
-  const mapAlpha = [
-    [0n, ''],
-    [1n, 'a'],
-    [26n, 'z'],
-    [26n + 1n, 'aa'],
-    [26n * 26n + 26n, 'zz'],
-    [26n * 26n + 26n + 1n, 'aaa'],
-  ];
-
-  it('num2bijectiveBI', () => {
-    map.map(([num, bij]) => {
-      expect(num2bijectiveBI(num)).toEqual(bij);
-    });
-  });
-
-  it('num2bijectiveBI alpha', () => {
-    mapAlpha.map(([num, bij]) => {
-      expect(num2bijectiveBI(num, alpha)).toEqual(bij);
-    });
-  });
-
-  it('bijective2numBI', () => {
-    map.map(([num, bij]) => {
-      expect(bijective2numBI(bij)).toEqual(num);
-    });
-  });
-
-  it('bijective2numBI alpha', () => {
-    mapAlpha.map(([num, bij]) => {
-      expect(bijective2numBI(bij, alpha)).toEqual(num);
-    });
-  });
-
-  it('random tests', () => {
-    for (let i = 0; i < 1e3; ++i) {
-      const b = BigInt(Math.round(Math.random() * 1000));
-      const n = BigInt(Math.round(Math.random() * 100));
-      const bi = b ** n;
-
-      const bj = num2bijectiveBI(bi, alpha);
-      expect(bijective2numBI(bj, alpha)).toEqual(bi);
-    }
-  });
-
-});

package/spec/binary-search.spec.mjs

@@ -1,91 +0,0 @@
-
-import {
-  binarySearchArr,
-  binarySearchLE,
-  binarySearchGE,
-  binarySearchRangeIncl,
-} from '../src/binary-search.mjs';
-
-describe('binarySearchArr', () => {
-  it('few cases', () => {
-    expect(binarySearchArr([1, 2, 3, 4], 1)).toBe(0);
-    expect(binarySearchArr([1, 2, 3, 4], 2)).toBe(1);
-    expect(binarySearchArr([1, 2, 3, 4], 3)).toBe(2);
-    expect(binarySearchArr([1, 2, 3, 4], 4)).toBe(3);
-    expect(binarySearchArr([1, 2, 3, 4], 0)).toBe(-1);
-    expect(binarySearchArr([1, 2, 3, 4], 5)).toBe(-1);
-  });
-});
-
-describe('binarySearchLE', () => {
-  it('mid group', () => {
-    const arr = [0,1,2,2,3];
-    expect(binarySearchLE(arr, -100)).toBe(-1);
-    expect(binarySearchLE(arr, 0)).toBe(0);
-    expect(binarySearchLE(arr, 1)).toBe(1);
-    expect(binarySearchLE(arr, 2)).toBe(3);
-    expect(binarySearchLE(arr, 3)).toBe(4);
-    expect(binarySearchLE(arr, 100)).toBe(4);
-  });
-
-  it('begin group', () => {
-    const arr = [2,2,3];
-    expect(binarySearchLE(arr, -100)).toBe(-1);
-    expect(binarySearchLE(arr, 2)).toBe(1);
-    expect(binarySearchLE(arr, 3)).toBe(2);
-    expect(binarySearchLE(arr, 100)).toBe(2);
-  });
-
-  it('end group', () => {
-    const arr = [1,2,2];
-    expect(binarySearchLE(arr, -100)).toBe(-1);
-    expect(binarySearchLE(arr, 1)).toBe(0);
-    expect(binarySearchLE(arr, 2)).toBe(2);
-    expect(binarySearchLE(arr, 100)).toBe(2);
-  });
-});
-
-describe('binarySearchGE', () => {
-  it('mid group', () => {
-    const arr = [0,1,2,2,3];
-    expect(binarySearchGE(arr, -100)).toBe(0);
-    expect(binarySearchGE(arr, 0)).toBe(0);
-    expect(binarySearchGE(arr, 1)).toBe(1);
-    expect(binarySearchGE(arr, 2)).toBe(2);
-    expect(binarySearchGE(arr, 3)).toBe(4);
-    expect(binarySearchGE(arr, 100)).toBe(5);
-  });
-
-  it('begin group', () => {
-    const arr = [2,2,3];
-    expect(binarySearchGE(arr, -100)).toBe(0);
-    expect(binarySearchGE(arr, 2)).toBe(0);
-    expect(binarySearchGE(arr, 3)).toBe(2);
-    expect(binarySearchGE(arr, 100)).toBe(3);
-  });
-
-  it('end group', () => {
-    const arr = [1,2,2];
-    expect(binarySearchGE(arr, -100)).toBe(0);
-    expect(binarySearchGE(arr, 1)).toBe(0);
-    expect(binarySearchGE(arr, 2)).toBe(1);
-    expect(binarySearchGE(arr, 100)).toBe(3);
-  });
-});
-
-describe('binarySearchRangeIncl', () => {
-  it('basic', () => {
-    const arr = [0,1,1,3];
-    const check = [-10, ...arr, 10];
-    const expected = [
-      [0, -1],
-      [0, 0], [1, 2], [1, 2], [3, 3],
-      [4, 3],
-    ];
-
-    for (let i = 0; i < check.length; ++i) {
-      expect(binarySearchRangeIncl(arr, check[i])).toEqual(expected[i]);
-    }
-  });
-});
-

package/spec/copy-case.spec.mjs

@@ -1,12 +0,0 @@
-
-import {
-  copyCase,
-} from '../src/copy-case.mjs';
-
-describe('copy-case', () => {
-  it('few tests', () => {
-    expect(copyCase('styczeń', 'january')).toBe('styczeń');
-    expect(copyCase('styczeń', 'January')).toBe('Styczeń');
-    expect(copyCase('styczeń', 'JANUARY')).toBe('STYCZEŃ');
-  });
-});

package/spec/factors.spec.mjs

@@ -1,35 +0,0 @@
-
-import {
-  factors,
-  factorsBI,
-} from '../src/factors.mjs';
-
-describe('factors', () => {
-  it('Number', () => {
-    expect(factors(0)).toEqual([]);
-    expect(factors(1)).toEqual([]);
-    expect(factors(2)).toEqual([2]);
-    expect(factors(3)).toEqual([3]);
-    expect(factors(4)).toEqual([2, 2]);
-    expect(factors(5)).toEqual([5]);
-    expect(factors(6)).toEqual([2, 3]);
-    expect(factors(7)).toEqual([7]);
-    expect(factors(8)).toEqual([2, 2, 2]);
-    expect(factors(9)).toEqual([3, 3]);
-    expect(factors(10)).toEqual([2, 5]);
-  });
-
-  it('BigInt', () => {
-    expect(factorsBI(0n)).toEqual([]);
-    expect(factorsBI(1n)).toEqual([]);
-    expect(factorsBI(2n)).toEqual([2n]);
-    expect(factorsBI(3n)).toEqual([3n]);
-    expect(factorsBI(4n)).toEqual([2n, 2n]);
-    expect(factorsBI(5n)).toEqual([5n]);
-    expect(factorsBI(6n)).toEqual([2n, 3n]);
-    expect(factorsBI(7n)).toEqual([7n]);
-    expect(factorsBI(8n)).toEqual([2n, 2n, 2n]);
-    expect(factorsBI(9n)).toEqual([3n, 3n]);
-    expect(factorsBI(10n)).toEqual([2n, 5n]);
-  });
-});

package/spec/gcd.spec.mjs

@@ -1,27 +0,0 @@
-
-import {
-  gcd,
-  gcdBI,
-} from '../src/gcd.mjs';
-
-describe('gcd', () => {
-  it('Number', () => {
-    expect(gcd(42, 56)).toEqual(14);
-    expect(gcd(461952, 116298)).toEqual(18);
-    expect(gcd(7966496, 314080416)).toEqual(32);
-    expect(gcd(24826148, 45296490)).toEqual(526);
-    expect(gcd(12, 0)).toEqual(12);
-    expect(gcd(0, 0)).toEqual(0);
-    expect(gcd(0, 9)).toEqual(9);
-  });
-
-  it('BigInt', () => {
-    expect(gcdBI(42n, 56n)).toEqual(14n);
-    expect(gcdBI(461952n, 116298n)).toEqual(18n);
-    expect(gcdBI(7966496n, 314080416n)).toEqual(32n);
-    expect(gcdBI(24826148n, 45296490n)).toEqual(526n);
-    expect(gcdBI(12n, 0n)).toEqual(12n);
-    expect(gcdBI(0n, 0n)).toEqual(0n);
-    expect(gcdBI(0n, 9n)).toEqual(9n);
-  });
-});

package/spec/get-type.spec.mjs

@@ -1,75 +0,0 @@
-
-import { getType } from '../src/get-type.mjs';
-
-describe('get-type', () => {
-
-  it('should undefined', () => {
-    expect(getType(undefined)).toEqual('undefined');
-  });
-
-  it('should null', () => {
-    expect(getType(null)).toEqual('null');
-  });
-
-  it('should boolean', () => {
-    expect(getType(true)).toEqual('boolean');
-    expect(getType(false)).toEqual('boolean');
-    expect(getType(new Boolean)).toEqual('boolean');
-  });
-
-  it('should number', () => {
-    expect(getType(1)).toEqual('number');
-    expect(getType(1e3)).toEqual('number');
-    expect(getType(1_000)).toEqual('number');
-    expect(getType(NaN)).toEqual('number');
-    expect(getType(Infinity)).toEqual('number');
-  });
-
-  it('should bigint', () => {
-    expect(getType(1n)).toEqual('bigint');
-  });
-
-  it('should string', () => {
-    expect(getType('hello')).toEqual('string');
-    expect(getType(new String)).toEqual('string');
-  });
-
-  it('should Symbol', () => {
-    expect(getType(Symbol())).toEqual('symbol');
-  });
-
-  it('should function', () => {
-    expect(getType(() => 0)).toEqual('function');
-    expect(getType(function() { })).toEqual('function');
-    expect(getType(new Function)).toEqual('function');
-  });
-
-  it('should generatorfunction', () => {
-    expect(getType(function*() { })).toEqual('generatorfunction');
-  });
-
-  it('should date', () => {
-    expect(getType(new Date)).toEqual('date');
-  });
-
-  it('should array', () => {
-    expect(getType([])).toEqual('array');
-    expect(getType(new Array)).toEqual('array');
-  });
-
-  it('should object', () => {
-    expect(getType({})).toEqual('object');
-    expect(getType(new Object)).toEqual('object');
-    expect(getType(new Proxy({}, {}))).toEqual('object');
-  });
-
-  it('should map', () => {
-    expect(getType(new Map)).toEqual('map');
-    expect(getType(new WeakMap)).toEqual('weakmap');
-  });
-
-  it('should set', () => {
-    expect(getType(new Set)).toEqual('set');
-    expect(getType(new WeakSet)).toEqual('weakset');
-  });
-});

package/spec/gpn.spec.mjs

@@ -1,35 +0,0 @@
-
-import {
-  gpn,
-  gpnBI,
-} from '../src/gpn.mjs';
-
-describe('gpn', () => {
-  it('first terms', () => {
-    expect(gpn(0)).toBe(0);
-    expect(gpn(1)).toBe(1);
-    expect(gpn(2)).toBe(2);
-    expect(gpn(3)).toBe(5);
-    expect(gpn(4)).toBe(7);
-    expect(gpn(5)).toBe(12);
-    expect(gpn(6)).toBe(15);
-    expect(gpn(7)).toBe(22);
-    expect(gpn(8)).toBe(26);
-    expect(gpn(9)).toBe(35);
-  });
-});
-
-describe('gpn BI', () => {
-  it('first terms', () => {
-    expect(gpnBI(0n)).toBe(0n);
-    expect(gpnBI(1n)).toBe(1n);
-    expect(gpnBI(2n)).toBe(2n);
-    expect(gpnBI(3n)).toBe(5n);
-    expect(gpnBI(4n)).toBe(7n);
-    expect(gpnBI(5n)).toBe(12n);
-    expect(gpnBI(6n)).toBe(15n);
-    expect(gpnBI(7n)).toBe(22n);
-    expect(gpnBI(8n)).toBe(26n);
-    expect(gpnBI(9n)).toBe(35n);
-  });
-});

package/spec/heap.spec.mjs

@@ -1,32 +0,0 @@
-
-import { Heap } from '../src/heap.mjs';
-
-describe('Heap', () => {
-  it('size', () => {
-    const heap = Heap();
-    expect(heap.size()).toBe(0);
-    heap.add(1);
-    expect(heap.size()).toBe(1);
-    heap.add(1);
-    heap.add(1);
-    expect(heap.size()).toBe(3);
-  });
-
-  it('take', () => {
-    const heap = Heap();
-    heap.add(2);
-    heap.add(1);
-    heap.add(3);
-    expect(heap.take()).toBe(1);
-    expect(heap.take()).toBe(2);
-    expect(heap.take()).toBe(3);
-  });
-
-  it('valFn', () => {
-    const heap = Heap(obj => obj.value);
-    heap.add({ value: 42, other: 'second' });
-    heap.add({ value: 23, other: 'first' });
-    expect(heap.take().other).toBe('first');
-    expect(heap.take().other).toBe('second');
-  });
-});

package/spec/herons-formula.spec.mjs

@@ -1,41 +0,0 @@
-
-import {
-  heronsFormula,
-  heronsFormulaBI,
-} from '../src/herons-formula.mjs';
-
-describe('herons-formula', () => {
-  it('Integer', () => {
-    expect(heronsFormula(5, 12, 13)).toEqual(30);
-    expect(heronsFormula(6, 8, 10)).toEqual(24);
-    expect(heronsFormula(7, 15, 20)).toEqual(42);
-    expect(heronsFormula(17, 17, 30)).toEqual(120);
-    expect(heronsFormula(13, 37, 30)).toEqual(180);
-    expect(heronsFormula(6, 25, 29)).toEqual(60);
-    expect(heronsFormula(73, 9, 80)).toEqual(216);
-    expect(heronsFormula(12, 35, 37)).toEqual(210);
-    expect(heronsFormula(120, 109, 13)).toEqual(396);
-    expect(heronsFormula(9, 10, 17)).toEqual(36);
-  });
-
-  it('Float', () => {
-    expect(heronsFormula(2, 3, 4)).toEqual(2.9047375096555625);
-    expect(heronsFormula(7, 10, 12)).toEqual(34.977671449083054);
-    expect(heronsFormula(6, 11, 12)).toEqual(32.839572165300815);
-    expect(heronsFormula(25, 25, 45)).toEqual(245.1880655741629);
-    expect(heronsFormula(10, 11, 18)).toEqual(48.59976851796724);
-  });
-
-  it('BigInt', () => {
-    expect(heronsFormulaBI(5n, 12n, 13n)).toEqual(30n);
-    expect(heronsFormulaBI(6n, 8n, 10n)).toEqual(24n);
-    expect(heronsFormulaBI(7n, 15n, 20n)).toEqual(42n);
-    expect(heronsFormulaBI(17n, 17n, 30n)).toEqual(120n);
-    expect(heronsFormulaBI(13n, 37n, 30n)).toEqual(180n);
-    expect(heronsFormulaBI(6n, 25n, 29n)).toEqual(60n);
-    expect(heronsFormulaBI(73n, 9n, 80n)).toEqual(216n);
-    expect(heronsFormulaBI(12n, 35n, 37n)).toEqual(210n);
-    expect(heronsFormulaBI(120n, 109n, 13n)).toEqual(396n);
-    expect(heronsFormulaBI(9n, 10n, 17n)).toEqual(36n);
-  });
-});