@gkucmierz/utils 1.1.6 → 1.2.0

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@gkucmierz/utils",
-  "version": "1.1.6",
+  "version": "1.2.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@gkucmierz/utils",
-      "version": "1.1.6",
+      "version": "1.2.0",
       "license": "MIT",
       "devDependencies": {
         "husky": "^8.0.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gkucmierz/utils",
-  "version": "1.1.6",
+  "version": "1.2.0",
   "description": "",
   "main": "src/main.mjs",
   "scripts": {

package/spec/bijective-numeration.spec.mjs

@@ -0,0 +1,105 @@
+
+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);
+    });
+  });
+
+});
+
+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);
+    });
+  });
+
+});

package/spec/get-type.spec.mjs

@@ -2,15 +2,74 @@
 import { getType } from '../src/get-type.mjs';
 
 describe('get-type', () => {
-  it('getType', function() {
+
+  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');
-    expect(getType('1')).toEqual('string');
+  });
+
+  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/range-array.spec.mjs

@@ -5,13 +5,13 @@ import {
 } from '../src/range-array.mjs';
 
 describe('range-array', () => {
-  it('array2range', function() {
+  it('array2range', () => {
     expect(array2range([])).toEqual([]);
     expect(array2range([1,3,4,5,7,9,10])).toEqual([[1,1],[3,5],[7,7],[9,10]]);
     expect(array2range([10,12,13,14,15,16,17,20,22,23,27])).toEqual([[10,10],[12,17],[20,20],[22,23],[27,27]]);
   });
 
-  it('range2array', function() {
+  it('range2array', () => {
     expect(range2array([])).toEqual([]);
     expect(range2array([[1],[3,5],[7],[9,10]])).toEqual([1,3,4,5,7,9,10]);
     expect(range2array([[10],[12,17],[20],[22,23],[27]])).toEqual([10,12,13,14,15,16,17,20,22,23,27]);

package/src/bijective-numeration.mjs

@@ -0,0 +1,54 @@
+
+export const num2bijective = (num, alpha = '12') => {
+  const len = alpha.length;
+  let c = 0;
+  let x = 1;
+  while (num >= x) {
+    c++;
+    num -= x;
+    x *= len;
+  }
+  const res = [];
+  for (let i = 0; i < c; i++) {
+    const rem = num % len;
+    res.unshift(alpha.charAt(num % len));
+    num = (num - rem) / len;
+  }
+  return res.join('');
+};
+
+export const bijective2num = (str, alpha = '12') => {
+  const map = new Map([...alpha].map((c, i) => [c, i]));
+  let res = 0;
+  const len = alpha.length;
+  return [...str].reduce((res, c) => {
+    return res * len + map.get(c) + 1;
+  }, 0);
+};
+
+export const num2bijectiveBI = (num, alpha = '12') => {
+  const len = BigInt(alpha.length);
+  let c = 0n;
+  let x = 1n;
+  while (num >= x) {
+    c++;
+    num -= x;
+    x *= len;
+  }
+  const res = [];
+  for (let i = 0n; i < c; i++) {
+    const rem = num % len;
+    res.unshift(alpha.charAt(Number(num % len)));
+    num = (num - rem) / len;
+  }
+  return res.join('');
+};
+
+export const bijective2numBI = (str, alpha = '12') => {
+  const map = new Map([...alpha].map((c, i) => [c, BigInt(i)]));
+  let res = 0n;
+  const len = BigInt(alpha.length);
+  return [...str].reduce((res, c) => {
+    return res * len + map.get(c) + 1n;
+  }, 0n);
+};