@datagrok-libraries/utils 0.0.18 → 0.0.23

package/package.json

@@ -4,11 +4,11 @@
     "access": "public"
   },
   "fullName": "Utils",
-  "version": "0.0.18",
+  "version": "0.0.23",
   "description": "Common utilities",
   "dependencies": {
     "@types/node": "^14.14.37",
-    "datagrok-api": ">=0.95.8",
+    "datagrok-api": ">=0.117.0",
     "dts-bundle": "^0.7.3",
     "js-yaml": "^4.1.0",
     "node-fetch": "^2.6.0"

package/src/array-utils.d.ts

@@ -0,0 +1,4 @@
+export declare namespace ArrayUtils {
+    function indexesOf<T>(values: T[], filter: (item: T) => boolean): number[];
+}
+//# sourceMappingURL=array-utils.d.ts.map

package/src/array-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-utils.d.ts","sourceRoot":"","sources":["array-utils.ts"],"names":[],"mappings":"AAAA,yBAAiB,UAAU,CAAC;IAE1B,SAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM,EAAE,CAMhF;CACF"}

package/src/array-utils.js

@@ -0,0 +1,12 @@
+export var ArrayUtils;
+(function (ArrayUtils) {
+    function indexesOf(values, filter) {
+        const indexes = [];
+        for (let i = 0; i < values.length; i++)
+            if (filter(values[i]))
+                indexes.push(i);
+        return indexes;
+    }
+    ArrayUtils.indexesOf = indexesOf;
+})(ArrayUtils || (ArrayUtils = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXktdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJhcnJheS11dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLEtBQVcsVUFBVSxDQVMxQjtBQVRELFdBQWlCLFVBQVU7SUFFekIsU0FBZ0IsU0FBUyxDQUFJLE1BQVcsRUFBRSxNQUE0QjtRQUNwRSxNQUFNLE9BQU8sR0FBRyxFQUFFLENBQUM7UUFDbkIsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxNQUFNLEVBQUUsQ0FBQyxFQUFFO1lBQ3BDLElBQUksTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQztnQkFDbkIsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNwQixPQUFPLE9BQU8sQ0FBQztJQUNqQixDQUFDO0lBTmUsb0JBQVMsWUFNeEIsQ0FBQTtBQUNILENBQUMsRUFUZ0IsVUFBVSxLQUFWLFVBQVUsUUFTMUIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgbmFtZXNwYWNlIEFycmF5VXRpbHMge1xuXG4gIGV4cG9ydCBmdW5jdGlvbiBpbmRleGVzT2Y8VD4odmFsdWVzOiBUW10sIGZpbHRlcjogKGl0ZW06IFQpID0+IGJvb2xlYW4pOiBudW1iZXJbXSB7XG4gICAgY29uc3QgaW5kZXhlcyA9IFtdO1xuICAgIGZvciAobGV0IGkgPSAwOyBpIDwgdmFsdWVzLmxlbmd0aDsgaSsrKVxuICAgICAgaWYgKGZpbHRlcih2YWx1ZXNbaV0pKVxuICAgICAgICBpbmRleGVzLnB1c2goaSk7XG4gICAgcmV0dXJuIGluZGV4ZXM7XG4gIH1cbn0iXX0=

package/src/operations.d.ts

@@ -74,4 +74,19 @@ export declare function genRange(begin: number, end: number, endExclusive?: bool
  * @return {number[]} The order computed.
  */
 export declare function argSort(values: any[], reverse?: boolean): number[];
+/**
+ * Returns the indexes of the most diverse objects according to the dist function
+ *
+ * @param {number} length total number of objects
+ * @param {number} n number of diverse elements to find
+ * @param {(i1: number, i2: number) => number} dist a function which calculates distance between two objects using their indexes
+ * @returns {number[]} The indexes of the most diverse objects
+ */
+export declare function getDiverseSubset(length: number, n: number, dist: (i1: number, i2: number) => number): number[];
+/**
+ * Returns normalized vector
+ *
+ * @param data numerical array
+ */
+export declare function normalize(data: Vector): Vector;
 //# sourceMappingURL=operations.d.ts.map

package/src/operations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["operations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAE,MAAM,EAAe,OAAO,EAAE,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAEzF;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,SAAS,GAAE,OAAe,EAAE,OAAO,GAAE,MAA2B,QAItF;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAeD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,GAAE,MAAU,GAAG,MAAM,CAW9E;AAiCD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,GAAE,MAAW,GAAG,MAAM,CASnG;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAKvE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM,CAWlF;AAED,iFAAiF;AACjF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,UAAQ,GAAG,UAAU,CAQrF;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,OAAO,UAAQ,GAAG,MAAM,EAAE,CAMhE"}
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["operations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAE,MAAM,EAAe,OAAO,EAAE,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAEzF;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,SAAS,GAAE,OAAe,EAAE,OAAO,GAAE,MAA2B,QAItF;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAeD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,GAAE,MAAU,GAAG,MAAM,CAW9E;AAiCD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,GAAE,MAAW,GAAG,MAAM,CASnG;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAKvE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM,CAWlF;AAED,iFAAiF;AACjF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,UAAQ,GAAG,UAAU,CAQrF;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,OAAO,UAAQ,GAAG,MAAM,EAAE,CAMhE;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,EAAE,CAoC9G;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkB9C"}

package/src/operations.js

@@ -165,4 +165,63 @@ export function argSort(values, reverse = false) {
     const _argsort = (arr) => arr.map(decor).sort(sortfn).map(undecor);
     return _argsort(values);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operations.js","sourceRoot":"","sources":["operations.ts"],"names":[],"mappings":"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","sourcesContent":["import {Matrix, Vector, Coordinates, Vectors, DistanceMetric} from './type-declarations';\n\n/**\n * Asserts a condition by throwing an Error.\n *\n * @export\n * @param {boolean} [condition=false] Condition to assert.\n * @param {string} [message='Assertion error.'] Message to output.\n * @throws {Error}\n */\nexport function assert(condition: boolean = false, message: string = 'Assertion error.') {\n  if (!condition) {\n    throw new Error(message);\n  }\n}\n\n/**\n * Generates single random integer from 0 to range.\n *\n * @export\n * @param {number} range Max generating value.\n * @return {number} A random integer generated.\n */\nexport function randomInt(range: number): number {\n  return Math.floor(Math.random() * range);\n}\n\n/**\n * Creates new two-dimensional array and fills it with the value given.\n *\n * @param {number} dimension1 The first dimension of the coordinates (number of rows).\n * @param {number} dimension2 The second dimension of the coordinates (number of columns).\n * @param {number} [fill=0] A value to fill the coordinates with.\n * @return {Coordinates} A two-dimensional filled with the value given.\n * @todo Might be slow since used Array.map. Probably needs performance revision.\n */\nfunction initCoordinates(dimension1: number, dimension2: number, fill: number = 0): Coordinates {\n  return new Array(dimension1).fill(fill).map(() => (new Vector(dimension2).fill(fill)));\n}\n\n/**\n * Transpose matrix.\n *\n * @export\n * @param {Matrix} matrix The matrix to be transposed.\n * @return {Matrix} Transposed matrix.\n * @todo Might be slow since used Array.map. Probably needs performance revision.\n */\nexport function transposeMatrix(matrix: Matrix): Matrix {\n  return new Array(matrix[0].length).fill(0).map((_, i) => (new Vector(matrix.length).fill(0).map((_, j) => (matrix[j][i]))));\n}\n\n/**\n * Adds two vectors with the second one to be multiplied by the given ratio.\n *\n * @export\n * @param {Vector} p The first vector to add.\n * @param {Vector} q The second vector to add.\n * @param {number} [multiplier=1] A multiplier to be used before the second vector is added.\n * @return {Vector} New vector contained the result of operation p+multiplier*q.\n */\nexport function vectorAdd(p: Vector, q: Vector, multiplier: number = 1): Vector {\n  const nItems = p.length;\n\n  assert(nItems == q.length, 'Vector lengths do not match.')\n\n  let total = new Vector(nItems);\n\n  for (let i = 0; i < p.length; ++i) {\n    total[i] = p[i]+multiplier*q[i];\n  }\n  return total;\n}\n\n/**\n * Sums the vector's items.\n *\n * @param {Vector} v The vector to be summed.\n * @return {number} The vector's items sum.\n */\nfunction itemsSum(v: Vector): number {\n  let total = 0;\n\n  for (let i = 0; i < v.length; ++i) {\n    total += v[i];\n  }\n  return total;\n}\n\n/**\n * Suqares the vector's items.\n *\n * @param {Vector} v The vector to square.\n * @return {Vector} A new vector containing the original's items squared.\n */\nfunction vectorSquare(v: Vector): Vector {\n  const nItems = v.length;\n  let total = new Vector(nItems);\n\n  for (let i = 0; i < v.length; ++i) {\n    total[i] = v[i]*v[i];\n  }\n  return total;\n}\n\n/**\n * Creates a matrix filled with random floating point values.\n *\n * @export\n * @param {number} dimension1 The first dimension of the matrix.\n * @param {number} dimension2 The second dimension of the matrix.\n * @param {number} [scale=1.] Max value given by random generator.\n * @return {Matrix} A new matrix filled with random floating point  values.\n */\nexport function fillRandomMatrix(dimension1: number, dimension2: number, scale: number = 1.): Matrix {\n  let matrix = initCoordinates(dimension1, dimension2);\n\n  for (let i = 0; i < dimension1; ++i) {\n    for (let j = 0; j < dimension2; ++j) {\n      matrix[i][j] = Math.random() * scale;\n    }\n  }\n  return matrix;\n}\n\n/**\n * Calculates Euclidean distance between two vectors.\n *\n * @export\n * @param {Vector} p The first vector.\n * @param {Vector} q The second vector.\n * @return {number} Euclidean distance between the given vectors.\n */\nexport function calculateEuclideanDistance(p: Vector, q: Vector): number {\n  const diff = vectorAdd(p, q, -1);\n  const sqdiff = vectorSquare(diff);\n  const sqdiffSumm = itemsSum(sqdiff);\n  return Math.sqrt(sqdiffSumm);\n}\n\n/**\n * Creates a distance matrix using a custom distance function.\n *\n * @export\n * @param {Vectors} data Input vectors to calculate distances.\n * @param {DistanceMetric} distance Custom distance function.\n * @return {Matrix} Calculated custom distance matrix.\n */\nexport function calcDistanceMatrix(data: Vectors, distance: DistanceMetric): Matrix {\n  const nItems = data.length;\n  let matrix = initCoordinates(nItems, nItems, 0);\n\n  for (let i = 0; i < nItems; ++i) {\n    for (let j = i+1; j < nItems; ++j) {\n      const d: number = (data[i] == null) || (data[j] == null) ? 0 : distance(data[i], data[j]);\n      matrix[i][j] = matrix[j][i] = d;\n    }\n  }\n  return matrix;\n}\n\n/** Generates array from a range [begin; end] or [begin; end) if endExclusive. */\nexport function genRange(begin: number, end: number, endExclusive = false): Int32Array {\n  const nItems = end - begin + (endExclusive ? 0 : 1);\n  const series = new Int32Array(nItems);\n\n  for (let i = 0; i < nItems; ++i) {\n    series[i] = begin + i;\n  }\n  return series;\n}\n\n/**  \n * Returns order of values as if they are sorted.\n *\n * @export\n * @param {any[]} values Input array.\n * @param {boolean} [reverse=false] Whether to return reversed order.\n * @return {number[]} The order computed.\n */\nexport function argSort(values: any[], reverse = false): number[] {\n  const sortfn = reverse ? (a: any[], b: any[]) => (b[0] - a[0]) : (a: any[], b: any[]) => (a[0] - b[0]);\n  const decor = (v: any, i: number) => [v, i]; // set index to value\n  const undecor = (a: any[]) => a[1]; // leave only index\n  const _argsort = (arr: any[]) => arr.map(decor).sort(sortfn).map(undecor);\n  return _argsort(values);\n}\n"]}
+/**
+ * Returns the indexes of the most diverse objects according to the dist function
+ *
+ * @param {number} length total number of objects
+ * @param {number} n number of diverse elements to find
+ * @param {(i1: number, i2: number) => number} dist a function which calculates distance between two objects using their indexes
+ * @returns {number[]} The indexes of the most diverse objects
+ */
+export function getDiverseSubset(length, n, dist) {
+    function maxBy(values, orderBy) {
+        let maxValue = null;
+        let maxOrderBy = null;
+        for (const element of values) {
+            let elementOrderBy = orderBy(element);
+            if (maxOrderBy == null || elementOrderBy > maxOrderBy) {
+                maxValue = element;
+                maxOrderBy = elementOrderBy;
+            }
+        }
+        return maxValue;
+    }
+    let subset = [randomInt(length - 1)];
+    let complement = new Set();
+    for (let i = 0; i < length; ++i) {
+        if (!subset.includes(i))
+            complement.add(i);
+    }
+    while (subset.length < n) {
+        let idx = maxBy(complement.values(), (i) => Math.min.apply(Math, subset.map(function (val, index) {
+            return dist(i, val);
+        })));
+        if (idx) {
+            subset.push(idx);
+            complement.delete(idx);
+        }
+    }
+    return subset;
+}
+/**
+ * Returns normalized vector
+ *
+ * @param data numerical array
+ */
+export function normalize(data) {
+    let mean = 0;
+    let std = 0;
+    data.forEach((val) => {
+        mean += val;
+    });
+    mean /= data.length;
+    data.forEach((val) => {
+        std += (val - mean) * (val - mean);
+    });
+    std = Math.sqrt(std / data.length);
+    data.forEach((val, idx) => {
+        data[idx] = (val - mean) / std;
+    });
+    return data;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operations.js","sourceRoot":"","sources":["operations.ts"],"names":[],"mappings":"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","sourcesContent":["import {Matrix, Vector, Coordinates, Vectors, DistanceMetric} from './type-declarations';\n\n/**\n * Asserts a condition by throwing an Error.\n *\n * @export\n * @param {boolean} [condition=false] Condition to assert.\n * @param {string} [message='Assertion error.'] Message to output.\n * @throws {Error}\n */\nexport function assert(condition: boolean = false, message: string = 'Assertion error.') {\n  if (!condition) {\n    throw new Error(message);\n  }\n}\n\n/**\n * Generates single random integer from 0 to range.\n *\n * @export\n * @param {number} range Max generating value.\n * @return {number} A random integer generated.\n */\nexport function randomInt(range: number): number {\n  return Math.floor(Math.random() * range);\n}\n\n/**\n * Creates new two-dimensional array and fills it with the value given.\n *\n * @param {number} dimension1 The first dimension of the coordinates (number of rows).\n * @param {number} dimension2 The second dimension of the coordinates (number of columns).\n * @param {number} [fill=0] A value to fill the coordinates with.\n * @return {Coordinates} A two-dimensional filled with the value given.\n * @todo Might be slow since used Array.map. Probably needs performance revision.\n */\nfunction initCoordinates(dimension1: number, dimension2: number, fill: number = 0): Coordinates {\n  return new Array(dimension1).fill(fill).map(() => (new Vector(dimension2).fill(fill)));\n}\n\n/**\n * Transpose matrix.\n *\n * @export\n * @param {Matrix} matrix The matrix to be transposed.\n * @return {Matrix} Transposed matrix.\n * @todo Might be slow since used Array.map. Probably needs performance revision.\n */\nexport function transposeMatrix(matrix: Matrix): Matrix {\n  return new Array(matrix[0].length).fill(0).map((_, i) => (new Vector(matrix.length).fill(0).map((_, j) => (matrix[j][i]))));\n}\n\n/**\n * Adds two vectors with the second one to be multiplied by the given ratio.\n *\n * @export\n * @param {Vector} p The first vector to add.\n * @param {Vector} q The second vector to add.\n * @param {number} [multiplier=1] A multiplier to be used before the second vector is added.\n * @return {Vector} New vector contained the result of operation p+multiplier*q.\n */\nexport function vectorAdd(p: Vector, q: Vector, multiplier: number = 1): Vector {\n  const nItems = p.length;\n\n  assert(nItems == q.length, 'Vector lengths do not match.')\n\n  let total = new Vector(nItems);\n\n  for (let i = 0; i < p.length; ++i) {\n    total[i] = p[i]+multiplier*q[i];\n  }\n  return total;\n}\n\n/**\n * Sums the vector's items.\n *\n * @param {Vector} v The vector to be summed.\n * @return {number} The vector's items sum.\n */\nfunction itemsSum(v: Vector): number {\n  let total = 0;\n\n  for (let i = 0; i < v.length; ++i) {\n    total += v[i];\n  }\n  return total;\n}\n\n/**\n * Suqares the vector's items.\n *\n * @param {Vector} v The vector to square.\n * @return {Vector} A new vector containing the original's items squared.\n */\nfunction vectorSquare(v: Vector): Vector {\n  const nItems = v.length;\n  let total = new Vector(nItems);\n\n  for (let i = 0; i < v.length; ++i) {\n    total[i] = v[i]*v[i];\n  }\n  return total;\n}\n\n/**\n * Creates a matrix filled with random floating point values.\n *\n * @export\n * @param {number} dimension1 The first dimension of the matrix.\n * @param {number} dimension2 The second dimension of the matrix.\n * @param {number} [scale=1.] Max value given by random generator.\n * @return {Matrix} A new matrix filled with random floating point  values.\n */\nexport function fillRandomMatrix(dimension1: number, dimension2: number, scale: number = 1.): Matrix {\n  let matrix = initCoordinates(dimension1, dimension2);\n\n  for (let i = 0; i < dimension1; ++i) {\n    for (let j = 0; j < dimension2; ++j) {\n      matrix[i][j] = Math.random() * scale;\n    }\n  }\n  return matrix;\n}\n\n/**\n * Calculates Euclidean distance between two vectors.\n *\n * @export\n * @param {Vector} p The first vector.\n * @param {Vector} q The second vector.\n * @return {number} Euclidean distance between the given vectors.\n */\nexport function calculateEuclideanDistance(p: Vector, q: Vector): number {\n  const diff = vectorAdd(p, q, -1);\n  const sqdiff = vectorSquare(diff);\n  const sqdiffSumm = itemsSum(sqdiff);\n  return Math.sqrt(sqdiffSumm);\n}\n\n/**\n * Creates a distance matrix using a custom distance function.\n *\n * @export\n * @param {Vectors} data Input vectors to calculate distances.\n * @param {DistanceMetric} distance Custom distance function.\n * @return {Matrix} Calculated custom distance matrix.\n */\nexport function calcDistanceMatrix(data: Vectors, distance: DistanceMetric): Matrix {\n  const nItems = data.length;\n  let matrix = initCoordinates(nItems, nItems, 0);\n\n  for (let i = 0; i < nItems; ++i) {\n    for (let j = i+1; j < nItems; ++j) {\n      const d: number = (data[i] == null) || (data[j] == null) ? 0 : distance(data[i], data[j]);\n      matrix[i][j] = matrix[j][i] = d;\n    }\n  }\n  return matrix;\n}\n\n/** Generates array from a range [begin; end] or [begin; end) if endExclusive. */\nexport function genRange(begin: number, end: number, endExclusive = false): Int32Array {\n  const nItems = end - begin + (endExclusive ? 0 : 1);\n  const series = new Int32Array(nItems);\n\n  for (let i = 0; i < nItems; ++i) {\n    series[i] = begin + i;\n  }\n  return series;\n}\n\n/**  \n * Returns order of values as if they are sorted.\n *\n * @export\n * @param {any[]} values Input array.\n * @param {boolean} [reverse=false] Whether to return reversed order.\n * @return {number[]} The order computed.\n */\nexport function argSort(values: any[], reverse = false): number[] {\n  const sortfn = reverse ? (a: any[], b: any[]) => (b[0] - a[0]) : (a: any[], b: any[]) => (a[0] - b[0]);\n  const decor = (v: any, i: number) => [v, i]; // set index to value\n  const undecor = (a: any[]) => a[1]; // leave only index\n  const _argsort = (arr: any[]) => arr.map(decor).sort(sortfn).map(undecor);\n  return _argsort(values);\n}\n\n/**\n * Returns the indexes of the most diverse objects according to the dist function\n * \n * @param {number} length total number of objects\n * @param {number} n number of diverse elements to find \n * @param {(i1: number, i2: number) => number} dist a function which calculates distance between two objects using their indexes\n * @returns {number[]} The indexes of the most diverse objects\n */\nexport function getDiverseSubset(length: number, n: number, dist: (i1: number, i2: number) => number): number[] {\n\n  function maxBy(values: IterableIterator<number>, orderBy: (i: number) => number) {\n    let maxValue = null;\n    let maxOrderBy = null;\n\n    for (const element of values) {\n      let elementOrderBy = orderBy(element);\n      if (maxOrderBy == null || elementOrderBy > maxOrderBy) {\n        maxValue = element;\n        maxOrderBy = elementOrderBy;\n      }\n    }\n    return maxValue;  \n  }\n\n  let subset = [randomInt(length - 1)];\n  let complement = new Set();\n\n  for (let i = 0; i < length; ++i) {\n    if (!subset.includes(i))\n      complement.add(i);\n  }\n\n  while (subset.length < n) {\n    let idx = maxBy(\n      complement.values() as IterableIterator<number>,\n      (i) => Math.min.apply(Math, subset.map(function (val, index) {\n        return dist(i, val); \n      })));\n    if (idx) {\n      subset.push(idx);\n      complement.delete(idx);\n    }\n  }\n  return subset;\n}\n\n/**\n * Returns normalized vector\n * \n * @param data numerical array\n */\nexport function normalize(data: Vector): Vector {\n  let mean = 0;\n  let std = 0;\n\n  data.forEach((val) => {\n    mean += val;\n  });\n  mean /= data.length;\n\n  data.forEach((val) => {\n    std += (val - mean) * (val - mean);\n  });\n  std = Math.sqrt(std / data.length);\n\n  data.forEach((val, idx) => {\n    data[idx] = (val - mean) / std;\n  });\n  return data;\n}"]}

package/src/similarity-metrics.d.ts

@@ -0,0 +1,85 @@
+import BitArray from './bit-array';
+export declare const similarityMetric: {
+    [name: string]: (x: BitArray, y: BitArray) => number;
+};
+/**
+ * Returns Tanimoto similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns tanimoto similarity
+ */
+export declare function tanimotoSimilarity(x: BitArray, y: BitArray): number;
+/**
+ * Returns Dice similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns dice similarity
+ */
+export declare function diceSimilarity(x: BitArray, y: BitArray): number;
+/**
+ * Returns Cosine similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns cosine similarity
+ */
+export declare function cosineSimilarity(x: BitArray, y: BitArray): number;
+/**
+ * Returns Sokal similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns sokal similarity
+ */
+export declare function sokalSimilarity(x: BitArray, y: BitArray): number;
+/**
+ * Returns Kulczynski similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns kulczynski similarity
+ */
+export declare function kulczynskiSimilarity(x: BitArray, y: BitArray): number;
+/**
+ * Returns McConnaughey similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns mcConnaughey similarity
+ */
+export declare function mcConnaugheySimilarity(x: BitArray, y: BitArray): number;
+/**
+ * Returns Asymmetric similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns asymmetric similarity
+ */
+export declare function asymmetricSimilarity(x: BitArray, y: BitArray): number;
+/**
+ * Returns Braun-Blanquet similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns braunBlanquet similarity
+ */
+export declare function braunBlanquetSimilarity(x: BitArray, y: BitArray): number;
+/**
+ * Returns Russel similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns russel similarity
+ */
+export declare function russelSimilarity(x: BitArray, y: BitArray): number;
+/**
+ * Returns Rogot-Goldberg similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns rogotGoldberg similarity
+ */
+export declare function rogotGoldbergSimilarity(x: BitArray, y: BitArray): number;
+//# sourceMappingURL=similarity-metrics.d.ts.map

package/src/similarity-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"similarity-metrics.d.ts","sourceRoot":"","sources":["similarity-metrics.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,aAAa,CAAA;AAElC,eAAO,MAAM,gBAAgB,EAAE;IAAC,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,KAAK,MAAM,CAAA;CAWnF,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAMnE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAM/D;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAMjE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAIhE;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAOrE;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAOvE;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAMrE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAMxE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAKjE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAOxE"}

package/src/similarity-metrics.js

@@ -0,0 +1,155 @@
+export const similarityMetric = {
+    'Tanimoto': tanimotoSimilarity,
+    'Dice': diceSimilarity,
+    'Asymmetric': asymmetricSimilarity,
+    'Braun-Blanquet': braunBlanquetSimilarity,
+    'Cosine': cosineSimilarity,
+    'Kulczynski': kulczynskiSimilarity,
+    'Mc-Connaughey': mcConnaugheySimilarity,
+    'Rogot-Goldberg': rogotGoldbergSimilarity,
+    'Russel': russelSimilarity,
+    'Sokal': sokalSimilarity,
+};
+/**
+ * Returns Tanimoto similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns tanimoto similarity
+ */
+export function tanimotoSimilarity(x, y) {
+    const total = x.trueCount() + y.trueCount();
+    if (total == 0)
+        return 1.0;
+    const common = x.andWithCountBits(y, true);
+    return common / (total - common);
+}
+/**
+ * Returns Dice similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns dice similarity
+ */
+export function diceSimilarity(x, y) {
+    const total = x.trueCount() + y.trueCount();
+    if (total == 0)
+        return 0.0;
+    const common = x.andWithCountBits(y, true);
+    return 2 * common / total;
+}
+/**
+ * Returns Cosine similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns cosine similarity
+ */
+export function cosineSimilarity(x, y) {
+    const total = x.trueCount() * y.trueCount();
+    if (total == 0)
+        return 0.0;
+    const common = x.andWithCountBits(y, true);
+    return common / Math.sqrt(total);
+}
+/**
+ * Returns Sokal similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns sokal similarity
+ */
+export function sokalSimilarity(x, y) {
+    const total = x.trueCount() + y.trueCount();
+    const common = x.andWithCountBits(y, true);
+    return common / (2 * total - 3 * common);
+}
+/**
+ * Returns Kulczynski similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns kulczynski similarity
+ */
+export function kulczynskiSimilarity(x, y) {
+    const total = x.trueCount() + y.trueCount();
+    const totalProd = x.trueCount() * y.trueCount();
+    if (totalProd == 0)
+        return 0.0;
+    const common = x.andWithCountBits(y, true);
+    return (common * total) / (2 * totalProd);
+}
+/**
+ * Returns McConnaughey similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns mcConnaughey similarity
+ */
+export function mcConnaugheySimilarity(x, y) {
+    const total = x.trueCount() + y.trueCount();
+    const totalProd = x.trueCount() * y.trueCount();
+    if (totalProd == 0)
+        return 0.0;
+    const common = x.andWithCountBits(y, true);
+    return (common * total - totalProd) / totalProd;
+}
+/**
+ * Returns Asymmetric similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns asymmetric similarity
+ */
+export function asymmetricSimilarity(x, y) {
+    const min = Math.min(x.trueCount(), y.trueCount());
+    if (min == 0)
+        return 0.0;
+    const common = x.andWithCountBits(y, true);
+    return common / min;
+}
+/**
+ * Returns Braun-Blanquet similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns braunBlanquet similarity
+ */
+export function braunBlanquetSimilarity(x, y) {
+    const max = Math.max(x.trueCount(), y.trueCount());
+    if (max == 0)
+        return 0.0;
+    const common = x.andWithCountBits(y, true);
+    return common / max;
+}
+/**
+ * Returns Russel similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns russel similarity
+ */
+export function russelSimilarity(x, y) {
+    if (x.length == 0)
+        return 0.0;
+    const common = x.andWithCountBits(y, true);
+    return common / x.length;
+}
+/**
+ * Returns Rogot-Goldberg similarity between two BitArray's
+ *
+ * @param {BitArray} x
+ * @param {BitArray} y
+ * @returns rogotGoldberg similarity
+ */
+export function rogotGoldbergSimilarity(x, y) {
+    let common = x.andWithCountBits(y, true);
+    let total = x.countBits(true) + y.countBits(true);
+    let len = x.length;
+    let diff = len - total + common;
+    if ((common == len) || (diff == len))
+        return 1.0;
+    else
+        return common / total + diff / (2 * len - total);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"similarity-metrics.js","sourceRoot":"","sources":["similarity-metrics.ts"],"names":[],"mappings":"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","sourcesContent":["import BitArray from './bit-array'\n\nexport const similarityMetric: {[name: string]: (x: BitArray, y: BitArray) => number} = {\n  'Tanimoto': tanimotoSimilarity,\n  'Dice': diceSimilarity,\n  'Asymmetric': asymmetricSimilarity,\n  'Braun-Blanquet': braunBlanquetSimilarity,\n  'Cosine': cosineSimilarity,\n  'Kulczynski': kulczynskiSimilarity,\n  'Mc-Connaughey': mcConnaugheySimilarity,\n  'Rogot-Goldberg': rogotGoldbergSimilarity,\n  'Russel': russelSimilarity,\n  'Sokal': sokalSimilarity,\n}\n\n/**\n * Returns Tanimoto similarity between two BitArray's\n * \n * @param {BitArray} x \n * @param {BitArray} y \n * @returns tanimoto similarity\n */\nexport function tanimotoSimilarity(x: BitArray, y: BitArray): number {\n  const total = x.trueCount() + y.trueCount();\n  if (total == 0)\n    return 1.0;\n  const common = x.andWithCountBits(y, true);\n  return common / (total - common);\n}\n\n/**\n * Returns Dice similarity between two BitArray's\n * \n * @param {BitArray} x \n * @param {BitArray} y \n * @returns dice similarity\n */\nexport function diceSimilarity(x: BitArray, y: BitArray): number {\n  const total = x.trueCount() + y.trueCount();\n  if (total == 0)\n    return 0.0;\n  const common = x.andWithCountBits(y, true);\n  return 2 * common / total;\n}\n\n/**\n * Returns Cosine similarity between two BitArray's\n * \n * @param {BitArray} x \n * @param {BitArray} y \n * @returns cosine similarity\n */\nexport function cosineSimilarity(x: BitArray, y: BitArray): number {\n  const total = x.trueCount() * y.trueCount();\n  if (total == 0)\n    return 0.0;\n  const common = x.andWithCountBits(y, true);\n  return common / Math.sqrt(total);\n}\n\n/**\n * Returns Sokal similarity between two BitArray's\n * \n * @param {BitArray} x \n * @param {BitArray} y \n * @returns sokal similarity\n */\nexport function sokalSimilarity(x: BitArray, y: BitArray): number {\n  const total = x.trueCount() + y.trueCount();\n  const common = x.andWithCountBits(y, true);\n  return common / (2 * total - 3 * common);\n}\n\n/**\n * Returns Kulczynski similarity between two BitArray's\n * \n * @param {BitArray} x \n * @param {BitArray} y \n * @returns kulczynski similarity\n */\nexport function kulczynskiSimilarity(x: BitArray, y: BitArray): number {\n  const total = x.trueCount() + y.trueCount();\n  const totalProd = x.trueCount() * y.trueCount();\n  if (totalProd == 0)\n    return 0.0;\n  const common = x.andWithCountBits(y, true);\n  return (common * total) / (2 * totalProd);\n}\n\n/**\n * Returns McConnaughey similarity between two BitArray's\n * \n * @param {BitArray} x \n * @param {BitArray} y \n * @returns mcConnaughey similarity\n */\nexport function mcConnaugheySimilarity(x: BitArray, y: BitArray): number {\n  const total = x.trueCount() + y.trueCount();\n  const totalProd = x.trueCount() * y.trueCount();\n  if (totalProd == 0)\n    return 0.0;\n  const common = x.andWithCountBits(y, true);\n  return (common * total - totalProd) / totalProd;\n}\n\n/**\n * Returns Asymmetric similarity between two BitArray's\n * \n * @param {BitArray} x \n * @param {BitArray} y \n * @returns asymmetric similarity\n */\nexport function asymmetricSimilarity(x: BitArray, y: BitArray): number {\n  const min = Math.min(x.trueCount(), y.trueCount());\n  if (min == 0)\n    return 0.0;\n  const common = x.andWithCountBits(y, true);\n  return common / min;\n}\n\n/**\n * Returns Braun-Blanquet similarity between two BitArray's\n * \n * @param {BitArray} x \n * @param {BitArray} y \n * @returns braunBlanquet similarity\n */\nexport function braunBlanquetSimilarity(x: BitArray, y: BitArray): number {\n  const max = Math.max(x.trueCount(), y.trueCount());\n  if (max == 0)\n    return 0.0;\n  const common = x.andWithCountBits(y, true);\n  return common / max;\n}\n\n/**\n * Returns Russel similarity between two BitArray's\n * \n * @param {BitArray} x \n * @param {BitArray} y \n * @returns russel similarity\n */\nexport function russelSimilarity(x: BitArray, y: BitArray): number {\n  if (x.length == 0)\n    return 0.0;\n  const common = x.andWithCountBits(y, true);\n  return common / x.length;\n}\n\n/**\n * Returns Rogot-Goldberg similarity between two BitArray's\n * \n * @param {BitArray} x \n * @param {BitArray} y \n * @returns rogotGoldberg similarity\n */\nexport function rogotGoldbergSimilarity(x: BitArray, y: BitArray): number {\n  let common = x.andWithCountBits(y, true);\n  let total = x.countBits(true) + y.countBits(true);\n  let len = x.length;\n  let diff = len - total + common;\n  if ((common == len) || (diff == len)) return 1.0;\n  else return common / total + diff / (2 * len - total);\n}"]}

package/src/string-utils.d.ts

@@ -1,2 +1,15 @@
 export declare function tryParseJson(s: string): any;
+export declare class StringUtils {
+    /**
+     * Returns a name that does not exist in [existingNames].
+     * If [existingNames] does not contain [initialName], returns [initialName].
+     * Otherwise, tries [choices], and if the names are taken already, returns a string in a form of 'initialName (i)'.
+     */
+    static getUniqueName(initialName: string, existingNames: string[], options?: {
+        auto?: boolean;
+        idx?: number;
+        render?: Function;
+        choices?: string[];
+    }): string;
+}
 //# sourceMappingURL=string-utils.d.ts.map

package/src/string-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"string-utils.d.ts","sourceRoot":"","sources":["string-utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAI,GAAG,CAO5C"}
+{"version":3,"file":"string-utils.d.ts","sourceRoot":"","sources":["string-utils.ts"],"names":[],"mappings":"AAEA,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAM3C;AAED,qBAAa,WAAW;IACtB;;;;OAIG;IACH,MAAM,CAAC,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,EAC7D,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,QAAQ,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,MAAM;CAG/F"}

package/src/string-utils.js

@@ -1,3 +1,4 @@
+let api = window;
 export function tryParseJson(s) {
     try {
         return JSON.parse(s);
@@ -6,4 +7,14 @@ export function tryParseJson(s) {
         return null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5nLXV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsic3RyaW5nLXV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sVUFBVSxZQUFZLENBQUMsQ0FBUztJQUNsQyxJQUFJO1FBQ0EsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDO0tBQ3hCO0lBQ0QsT0FBTyxDQUFDLEVBQUU7UUFDTixPQUFPLElBQUksQ0FBQztLQUNmO0FBQ0wsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiB0cnlQYXJzZUpzb24oczogc3RyaW5nKSA6IGFueSB7XG4gICAgdHJ5IHtcbiAgICAgICAgcmV0dXJuIEpTT04ucGFyc2Uocyk7XG4gICAgfVxuICAgIGNhdGNoIChfKSB7XG4gICAgICAgIHJldHVybiBudWxsO1xuICAgIH1cbn0iXX0=
+export class StringUtils {
+    /**
+     * Returns a name that does not exist in [existingNames].
+     * If [existingNames] does not contain [initialName], returns [initialName].
+     * Otherwise, tries [choices], and if the names are taken already, returns a string in a form of 'initialName (i)'.
+     */
+    static getUniqueName(initialName, existingNames, options) {
+        return api.grok_Utils_GetUniqueName(initialName, existingNames, options === null || options === void 0 ? void 0 : options.auto, options === null || options === void 0 ? void 0 : options.idx, options === null || options === void 0 ? void 0 : options.render, options === null || options === void 0 ? void 0 : options.choices);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5nLXV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsic3RyaW5nLXV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLElBQUksR0FBRyxHQUFRLE1BQU0sQ0FBQztBQUV0QixNQUFNLFVBQVUsWUFBWSxDQUFDLENBQVM7SUFDcEMsSUFBSTtRQUNGLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQztLQUN0QjtJQUFDLE9BQU8sQ0FBQyxFQUFFO1FBQ1YsT0FBTyxJQUFJLENBQUM7S0FDYjtBQUNILENBQUM7QUFFRCxNQUFNLE9BQU8sV0FBVztJQUN0Qjs7OztPQUlHO0lBQ0gsTUFBTSxDQUFDLGFBQWEsQ0FBQyxXQUFtQixFQUFFLGFBQXVCLEVBQzdELE9BQWlGO1FBQ25GLE9BQU8sR0FBRyxDQUFDLHdCQUF3QixDQUFDLFdBQVcsRUFBRSxhQUFhLEVBQUUsT0FBTyxhQUFQLE9BQU8sdUJBQVAsT0FBTyxDQUFFLElBQUksRUFBRSxPQUFPLGFBQVAsT0FBTyx1QkFBUCxPQUFPLENBQUUsR0FBRyxFQUFFLE9BQU8sYUFBUCxPQUFPLHVCQUFQLE9BQU8sQ0FBRSxNQUFNLEVBQUUsT0FBTyxhQUFQLE9BQU8sdUJBQVAsT0FBTyxDQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ2xJLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImxldCBhcGkgPSA8YW55PndpbmRvdztcblxuZXhwb3J0IGZ1bmN0aW9uIHRyeVBhcnNlSnNvbihzOiBzdHJpbmcpOiBhbnkge1xuICB0cnkge1xuICAgIHJldHVybiBKU09OLnBhcnNlKHMpO1xuICB9IGNhdGNoIChfKSB7XG4gICAgcmV0dXJuIG51bGw7XG4gIH1cbn1cblxuZXhwb3J0IGNsYXNzIFN0cmluZ1V0aWxzIHtcbiAgLyoqXG4gICAqIFJldHVybnMgYSBuYW1lIHRoYXQgZG9lcyBub3QgZXhpc3QgaW4gW2V4aXN0aW5nTmFtZXNdLlxuICAgKiBJZiBbZXhpc3RpbmdOYW1lc10gZG9lcyBub3QgY29udGFpbiBbaW5pdGlhbE5hbWVdLCByZXR1cm5zIFtpbml0aWFsTmFtZV0uXG4gICAqIE90aGVyd2lzZSwgdHJpZXMgW2Nob2ljZXNdLCBhbmQgaWYgdGhlIG5hbWVzIGFyZSB0YWtlbiBhbHJlYWR5LCByZXR1cm5zIGEgc3RyaW5nIGluIGEgZm9ybSBvZiAnaW5pdGlhbE5hbWUgKGkpJy5cbiAgICovXG4gIHN0YXRpYyBnZXRVbmlxdWVOYW1lKGluaXRpYWxOYW1lOiBzdHJpbmcsIGV4aXN0aW5nTmFtZXM6IHN0cmluZ1tdLFxuICAgICAgb3B0aW9ucz86IHsgYXV0bz86IGJvb2xlYW4sIGlkeD86IG51bWJlciwgcmVuZGVyPzogRnVuY3Rpb24sIGNob2ljZXM/OiBzdHJpbmdbXSB9KTogc3RyaW5nIHtcbiAgICByZXR1cm4gYXBpLmdyb2tfVXRpbHNfR2V0VW5pcXVlTmFtZShpbml0aWFsTmFtZSwgZXhpc3RpbmdOYW1lcywgb3B0aW9ucz8uYXV0bywgb3B0aW9ucz8uaWR4LCBvcHRpb25zPy5yZW5kZXIsIG9wdGlvbnM/LmNob2ljZXMpO1xuICB9XG59XG4iXX0=

package/src/test.d.ts

@@ -8,6 +8,9 @@ export declare let tests: {
     };
 };
 export declare let currentCategory: string;
+export declare namespace assure {
+    function notNull(value: any, name?: string): void;
+}
 export declare class Test {
     test: () => Promise<any>;
     name: string;
@@ -15,8 +18,13 @@ export declare class Test {
     constructor(category: string, name: string, test: () => Promise<any>);
 }
 export declare function test(name: string, test: () => Promise<any>): void;
+/** Awaits for a while checking the error status of the platform */
+export declare function testAssureNoError(ms: number): Promise<boolean>;
+/** Does best effort to catch all exceptional situations. Currently doesn't catch "Uncaught in promise" */
+export declare function testExpectFinish(name: string, foo: () => Promise<any>, ms?: number): Promise<void>;
 /** Tests two objects for equality, throws an exception if they are not equal. */
 export declare function expect(actual: any, expected: any): void;
+export declare function expectFloat(actual: number, expected: number, tolerance?: number): void;
 /** Defines a test suite. */
 export declare function category(category: string, tests: () => void): void;
 /** Defines a function to be executed before the tests in this category are executed. */

package/src/test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["test.ts"],"names":[],"mappings":"AACA,eAAO,IAAI,KAAK,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG;QAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAC,CAAA;CAAM,CAAC;AAEjK,eAAO,IAAI,eAAe,EAAE,MAAM,CAAC;AAEnC,qBAAa,IAAI;IACf,IAAI,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;gBAEL,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC;CAKrE;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAMjE;AAED,iFAAiF;AACjF,wBAAgB,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,QAGhD;AAED,4BAA4B;AAC5B,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,IAAI,GAAG,IAAI,CAGlE;AAED,wFAAwF;AACxF,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAIxD;AAED,uFAAuF;AACvF,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAItD;AAGD,wBAAsB,QAAQ,CAAC,OAAO,CAAC,EAAE;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAC;;;aACf,OAAO;YAAU,MAAM;KAkClF;AAiBD,wBAAsB,KAAK,CAAC,EAAE,EAAE,MAAM,iBAErC"}
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["test.ts"],"names":[],"mappings":"AAEA,eAAO,IAAI,KAAK,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG;QAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAC,CAAA;CAAM,CAAC;AAEjK,eAAO,IAAI,eAAe,EAAE,MAAM,CAAC;AAEnC,yBAAiB,MAAM,CAAC;IAEtB,SAAgB,OAAO,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,MAAM,QAGhD;CACF;AAED,qBAAa,IAAI;IACf,IAAI,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;gBAEL,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC;CAKrE;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAMjE;AAED,mEAAmE;AACnE,wBAAsB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQpE;AAED,0GAA0G;AAC1G,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,GAAE,MAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAY9G;AAED,iFAAiF;AACjF,wBAAgB,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,GAAG,IAAI,CAGvD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,SAAQ,GAAG,IAAI,CAIrF;AAED,4BAA4B;AAC5B,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,IAAI,GAAG,IAAI,CAGlE;AAED,wFAAwF;AACxF,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAIxD;AAED,uFAAuF;AACvF,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAItD;AAGD,wBAAsB,QAAQ,CAAC,OAAO,CAAC,EAAE;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAC;;;aACf,OAAO;YAAU,MAAM;KAkClF;AAiBD,wBAAsB,KAAK,CAAC,EAAE,EAAE,MAAM,iBAErC"}

package/src/test.js

@@ -7,8 +7,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import * as grok from "datagrok-api/grok";
 export let tests = {};
 export let currentCategory;
+export var assure;
+(function (assure) {
+    function notNull(value, name) {
+        if (value == null)
+            throw `${name == null ? 'Value' : name} not defined`;
+    }
+    assure.notNull = notNull;
+})(assure || (assure = {}));
 export class Test {
     constructor(category, name, test) {
         this.category = category;
@@ -23,11 +32,45 @@ export function test(name, test) {
         tests[currentCategory].tests = [];
     tests[currentCategory].tests.push(new Test(currentCategory, name, test));
 }
+/** Awaits for a while checking the error status of the platform */
+export function testAssureNoError(ms) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const timer = (ms) => new Promise(res => setTimeout(res, ms));
+        for (let i = 0; i < ms / 500; ++i) {
+            yield timer(500);
+            if (grok.shell.lastError.length !== 0)
+                return false;
+        }
+        return true;
+    });
+}
+/** Does best effort to catch all exceptional situations. Currently doesn't catch "Uncaught in promise" */
+export function testExpectFinish(name, foo, ms = 5000) {
+    return __awaiter(this, void 0, void 0, function* () {
+        test(name, () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                grok.shell.lastError = '';
+                yield foo();
+            }
+            catch (e) {
+                throw "Exception is not expected";
+            }
+            let noError = yield testAssureNoError(ms);
+            if (!noError)
+                throw "Exceptions while waiting for results";
+        }));
+    });
+}
 /** Tests two objects for equality, throws an exception if they are not equal. */
 export function expect(actual, expected) {
     if (actual !== expected)
         throw `Expected "${expected}", got "${actual}"`;
 }
+export function expectFloat(actual, expected, tolerance = 0.001) {
+    const areEqual = Math.abs(actual - expected) < 0.001;
+    if (!areEqual)
+        throw `Expected ${expected}, got ${actual} (tolerance = ${tolerance})"`;
+}
 /** Defines a test suite. */
 export function category(category, tests) {
     currentCategory = category;
@@ -106,4 +149,4 @@ export function delay(ms) {
         yield new Promise(r => setTimeout(r, ms));
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.js","sourceRoot":"","sources":["test.ts"],"names":[],"mappings":"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","sourcesContent":["\nexport let tests: {[key: string]: {tests?: Test[], before?: () => Promise<void>, after?: () => Promise<void>, beforeStatus?: string, afterStatus?: string}} = {};\n\nexport let currentCategory: string;\n\nexport class Test {\n  test: () => Promise<any>;\n  name: string;\n  category: string;\n\n  constructor(category: string, name: string, test: () => Promise<any>) {\n    this.category = category;\n    this.name = name;\n    this.test = test;\n  }\n}\n\nexport function test(name: string, test: () => Promise<any>): void {\n  if (tests[currentCategory] == undefined)\n    tests[currentCategory] = {};\n  if (tests[currentCategory].tests == undefined)\n    tests[currentCategory].tests = [];\n  tests[currentCategory].tests!.push(new Test(currentCategory, name , test));\n}\n\n/** Tests two objects for equality, throws an exception if they are not equal. */\nexport function expect(actual: any, expected: any) {\n  if (actual !== expected)\n    throw `Expected \"${expected}\", got \"${actual}\"`;\n}\n\n/** Defines a test suite. */\nexport function category(category: string, tests: () => void): void {\n  currentCategory = category;\n  tests();\n}\n\n/** Defines a function to be executed before the tests in this category are executed. */\nexport function before(before: () => Promise<void>): void {\n  if (tests[currentCategory] == undefined)\n    tests[currentCategory] = {};\n  tests[currentCategory].before = before;\n}\n\n/** Defines a function to be executed after the tests in this category are executed. */\nexport function after(after: () => Promise<void>): void {\n  if (tests[currentCategory] == undefined)\n    tests[currentCategory] = {};\n  tests[currentCategory].after = after;\n}\n\n\nexport async function runTests(options?: {category?: string, test?: string}) {\n  let results: { category?: string, name?: string, success: boolean, result: string}[] = [];\n\n  for (const [key, value] of Object.entries(tests)) {\n    if (options?.category != undefined) {\n      if (!key.toLowerCase().startsWith(options?.category.toLowerCase()))\n        continue;\n    }\n    try {\n      if (value.before)\n        await value.before();\n    } catch (x: any) {\n      value.beforeStatus = x.toString();\n    }\n    let t = value.tests ?? [];\n    let res = [];\n    for(let i = 0; i < t.length; i++) {\n      res.push(await execTest(t[i], options?.test));\n    }\n\n    let data = (await Promise.all(res)).filter((d) => d.result != 'skipped');\n    try {\n      if (value.after)\n        await value.after();\n    } catch (x: any) {\n      value.afterStatus = x.toString();\n    }\n    if (value.afterStatus)\n      data.push({category: key, name: 'init', result: value.afterStatus, success: false});\n    if (value.beforeStatus)\n      data.push({category: key, name: 'init', result: value.beforeStatus, success: false});\n    results.push(...data);\n  }\n\n  return results;\n}\n\nasync function execTest(t: Test, predicate: string | undefined) {\n  let r: { category?: string, name?: string, success: boolean, result: string };\n  try {\n    if (predicate != undefined && (!t.name.toLowerCase().startsWith(predicate.toLowerCase())))\n      r = {success: true, result: 'skipped'};\n    else\n      r = {success: true, result: await t.test() ?? 'OK'};\n  } catch (x: any) {\n    r = {success: false, result: x.toString()};\n  }\n  r.category = t.category;\n  r.name = t.name;\n  return r;\n}\n\nexport async function delay(ms: number) {\n  await  new Promise(r => setTimeout(r, ms));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.js","sourceRoot":"","sources":["test.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,KAAK,IAAI,MAAM,mBAAmB,CAAC;AAE1C,MAAM,CAAC,IAAI,KAAK,GAA8I,EAAE,CAAC;AAEjK,MAAM,CAAC,IAAI,eAAuB,CAAC;AAEnC,MAAM,KAAW,MAAM,CAMtB;AAND,WAAiB,MAAM;IAErB,SAAgB,OAAO,CAAC,KAAU,EAAE,IAAa;QAC/C,IAAI,KAAK,IAAI,IAAI;YACf,MAAM,GAAG,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,cAAc,CAAC;IACzD,CAAC;IAHe,cAAO,UAGtB,CAAA;AACH,CAAC,EANgB,MAAM,KAAN,MAAM,QAMtB;AAED,MAAM,OAAO,IAAI;IAKf,YAAY,QAAgB,EAAE,IAAY,EAAE,IAAwB;QAClE,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AAED,MAAM,UAAU,IAAI,CAAC,IAAY,EAAE,IAAwB;IACzD,IAAI,KAAK,CAAC,eAAe,CAAC,IAAI,SAAS;QACrC,KAAK,CAAC,eAAe,CAAC,GAAG,EAAE,CAAC;IAC9B,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC,KAAK,IAAI,SAAS;QAC3C,KAAK,CAAC,eAAe,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;IACpC,KAAK,CAAC,eAAe,CAAC,CAAC,KAAM,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,eAAe,EAAE,IAAI,EAAG,IAAI,CAAC,CAAC,CAAC;AAC7E,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAgB,iBAAiB,CAAC,EAAU;;QAChD,MAAM,KAAK,GAAG,CAAC,EAAU,EAAE,EAAE,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;QACtE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,CAAC,EAAE;YACjC,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;YACjB,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC;gBACnC,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CAAA;AAED,0GAA0G;AAC1G,MAAM,UAAgB,gBAAgB,CAAC,IAAY,EAAE,GAAuB,EAAE,KAAa,IAAI;;QAC7F,IAAI,CAAC,IAAI,EAAE,GAAuB,EAAE;YAClC,IAAI;gBACF,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,EAAE,CAAC;gBAC1B,MAAM,GAAG,EAAE,CAAC;aACb;YAAC,OAAO,CAAM,EAAE;gBACf,MAAM,2BAA2B,CAAC;aACnC;YACD,IAAI,OAAO,GAAG,MAAM,iBAAiB,CAAC,EAAE,CAAC,CAAC;YAC1C,IAAI,CAAC,OAAO;gBACV,MAAM,sCAAsC,CAAC;QACjD,CAAC,CAAA,CAAC,CAAC;IACL,CAAC;CAAA;AAED,iFAAiF;AACjF,MAAM,UAAU,MAAM,CAAC,MAAW,EAAE,QAAa;IAC/C,IAAI,MAAM,KAAK,QAAQ;QACrB,MAAM,aAAa,QAAQ,WAAW,MAAM,GAAG,CAAC;AACpD,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,MAAc,EAAE,QAAgB,EAAE,SAAS,GAAG,KAAK;IAC7E,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,QAAQ,CAAC,GAAG,KAAK,CAAC;IACrD,IAAI,CAAC,QAAQ;QACX,MAAM,YAAY,QAAQ,SAAS,MAAM,iBAAiB,SAAS,IAAI,CAAC;AAC5E,CAAC;AAED,4BAA4B;AAC5B,MAAM,UAAU,QAAQ,CAAC,QAAgB,EAAE,KAAiB;IAC1D,eAAe,GAAG,QAAQ,CAAC;IAC3B,KAAK,EAAE,CAAC;AACV,CAAC;AAED,wFAAwF;AACxF,MAAM,UAAU,MAAM,CAAC,MAA2B;IAChD,IAAI,KAAK,CAAC,eAAe,CAAC,IAAI,SAAS;QACrC,KAAK,CAAC,eAAe,CAAC,GAAG,EAAE,CAAC;IAC9B,KAAK,CAAC,eAAe,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC;AACzC,CAAC;AAED,uFAAuF;AACvF,MAAM,UAAU,KAAK,CAAC,KAA0B;IAC9C,IAAI,KAAK,CAAC,eAAe,CAAC,IAAI,SAAS;QACrC,KAAK,CAAC,eAAe,CAAC,GAAG,EAAE,CAAC;IAC9B,KAAK,CAAC,eAAe,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC;AACvC,CAAC;AAGD,MAAM,UAAgB,QAAQ,CAAC,OAA4C;;;QACzE,IAAI,OAAO,GAA4E,EAAE,CAAC;QAE1F,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YAChD,IAAI,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,QAAQ,KAAI,SAAS,EAAE;gBAClC,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,QAAQ,CAAC,WAAW,EAAE,CAAC;oBAChE,SAAS;aACZ;YACD,IAAI;gBACF,IAAI,KAAK,CAAC,MAAM;oBACd,MAAM,KAAK,CAAC,MAAM,EAAE,CAAC;aACxB;YAAC,OAAO,CAAM,EAAE;gBACf,KAAK,CAAC,YAAY,GAAG,CAAC,CAAC,QAAQ,EAAE,CAAC;aACnC;YACD,IAAI,CAAC,GAAG,MAAA,KAAK,CAAC,KAAK,mCAAI,EAAE,CAAC;YAC1B,IAAI,GAAG,GAAG,EAAE,CAAC;YACb,KAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBAChC,GAAG,CAAC,IAAI,CAAC,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,IAAI,CAAC,CAAC,CAAC;aAC/C;YAED,IAAI,IAAI,GAAG,CAAC,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,IAAI,SAAS,CAAC,CAAC;YACzE,IAAI;gBACF,IAAI,KAAK,CAAC,KAAK;oBACb,MAAM,KAAK,CAAC,KAAK,EAAE,CAAC;aACvB;YAAC,OAAO,CAAM,EAAE;gBACf,KAAK,CAAC,WAAW,GAAG,CAAC,CAAC,QAAQ,EAAE,CAAC;aAClC;YACD,IAAI,KAAK,CAAC,WAAW;gBACnB,IAAI,CAAC,IAAI,CAAC,EAAC,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,WAAW,EAAE,OAAO,EAAE,KAAK,EAAC,CAAC,CAAC;YACtF,IAAI,KAAK,CAAC,YAAY;gBACpB,IAAI,CAAC,IAAI,CAAC,EAAC,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,YAAY,EAAE,OAAO,EAAE,KAAK,EAAC,CAAC,CAAC;YACvF,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;SACvB;QAED,OAAO,OAAO,CAAC;;CAChB;AAED,SAAe,QAAQ,CAAC,CAAO,EAAE,SAA6B;;;QAC5D,IAAI,CAAyE,CAAC;QAC9E,IAAI;YACF,IAAI,SAAS,IAAI,SAAS,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,CAAC;gBACvF,CAAC,GAAG,EAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAC,CAAC;;gBAEvC,CAAC,GAAG,EAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAA,MAAM,CAAC,CAAC,IAAI,EAAE,mCAAI,IAAI,EAAC,CAAC;SACvD;QAAC,OAAO,CAAM,EAAE;YACf,CAAC,GAAG,EAAC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,EAAC,CAAC;SAC5C;QACD,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC;QACxB,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC;QAChB,OAAO,CAAC,CAAC;;CACV;AAED,MAAM,UAAgB,KAAK,CAAC,EAAU;;QACpC,MAAO,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;IAC7C,CAAC;CAAA","sourcesContent":["import * as grok from \"datagrok-api/grok\";\n\nexport let tests: {[key: string]: {tests?: Test[], before?: () => Promise<void>, after?: () => Promise<void>, beforeStatus?: string, afterStatus?: string}} = {};\n\nexport let currentCategory: string;\n\nexport namespace assure {\n\n  export function notNull(value: any, name?: string) {\n    if (value == null)\n      throw `${name == null ? 'Value' : name} not defined`;\n  }\n}\n\nexport class Test {\n  test: () => Promise<any>;\n  name: string;\n  category: string;\n\n  constructor(category: string, name: string, test: () => Promise<any>) {\n    this.category = category;\n    this.name = name;\n    this.test = test;\n  }\n}\n\nexport function test(name: string, test: () => Promise<any>): void {\n  if (tests[currentCategory] == undefined)\n    tests[currentCategory] = {};\n  if (tests[currentCategory].tests == undefined)\n    tests[currentCategory].tests = [];\n  tests[currentCategory].tests!.push(new Test(currentCategory, name , test));\n}\n\n/** Awaits for a while checking the error status of the platform */\nexport async function testAssureNoError(ms: number): Promise<boolean> {\n  const timer = (ms: number) => new Promise(res => setTimeout(res, ms));\n  for (let i = 0; i < ms / 500; ++i) {\n    await timer(500);\n    if (grok.shell.lastError.length !== 0)\n      return false;\n  }\n  return true;\n}\n\n/** Does best effort to catch all exceptional situations. Currently doesn't catch \"Uncaught in promise\" */\nexport async function testExpectFinish(name: string, foo: () => Promise<any>, ms: number = 5000): Promise<void> {\n  test(name, async (): Promise<any> => {\n    try {\n      grok.shell.lastError = '';\n      await foo();\n    } catch (e: any) {\n      throw \"Exception is not expected\";\n    }\n    let noError = await testAssureNoError(ms);\n    if (!noError)\n      throw \"Exceptions while waiting for results\";\n  });\n}\n\n/** Tests two objects for equality, throws an exception if they are not equal. */\nexport function expect(actual: any, expected: any): void {\n  if (actual !== expected)\n    throw `Expected \"${expected}\", got \"${actual}\"`;\n}\n\nexport function expectFloat(actual: number, expected: number, tolerance = 0.001): void {\n  const areEqual = Math.abs(actual - expected) < 0.001;\n  if (!areEqual)\n    throw `Expected ${expected}, got ${actual} (tolerance = ${tolerance})\"`;\n}\n\n/** Defines a test suite. */\nexport function category(category: string, tests: () => void): void {\n  currentCategory = category;\n  tests();\n}\n\n/** Defines a function to be executed before the tests in this category are executed. */\nexport function before(before: () => Promise<void>): void {\n  if (tests[currentCategory] == undefined)\n    tests[currentCategory] = {};\n  tests[currentCategory].before = before;\n}\n\n/** Defines a function to be executed after the tests in this category are executed. */\nexport function after(after: () => Promise<void>): void {\n  if (tests[currentCategory] == undefined)\n    tests[currentCategory] = {};\n  tests[currentCategory].after = after;\n}\n\n\nexport async function runTests(options?: {category?: string, test?: string}) {\n  let results: { category?: string, name?: string, success: boolean, result: string}[] = [];\n\n  for (const [key, value] of Object.entries(tests)) {\n    if (options?.category != undefined) {\n      if (!key.toLowerCase().startsWith(options?.category.toLowerCase()))\n        continue;\n    }\n    try {\n      if (value.before)\n        await value.before();\n    } catch (x: any) {\n      value.beforeStatus = x.toString();\n    }\n    let t = value.tests ?? [];\n    let res = [];\n    for(let i = 0; i < t.length; i++) {\n      res.push(await execTest(t[i], options?.test));\n    }\n\n    let data = (await Promise.all(res)).filter((d) => d.result != 'skipped');\n    try {\n      if (value.after)\n        await value.after();\n    } catch (x: any) {\n      value.afterStatus = x.toString();\n    }\n    if (value.afterStatus)\n      data.push({category: key, name: 'init', result: value.afterStatus, success: false});\n    if (value.beforeStatus)\n      data.push({category: key, name: 'init', result: value.beforeStatus, success: false});\n    results.push(...data);\n  }\n\n  return results;\n}\n\nasync function execTest(t: Test, predicate: string | undefined) {\n  let r: { category?: string, name?: string, success: boolean, result: string };\n  try {\n    if (predicate != undefined && (!t.name.toLowerCase().startsWith(predicate.toLowerCase())))\n      r = {success: true, result: 'skipped'};\n    else\n      r = {success: true, result: await t.test() ?? 'OK'};\n  } catch (x: any) {\n    r = {success: false, result: x.toString()};\n  }\n  r.category = t.category;\n  r.name = t.name;\n  return r;\n}\n\nexport async function delay(ms: number) {\n  await  new Promise(r => setTimeout(r, ms));\n}\n"]}

package/src/type-declarations.d.ts

@@ -53,4 +53,13 @@ export declare type Options = {
  * @return {number} Distance between these two vectors.
  */
 export declare type DistanceMetric = (v1: any, v2: any) => (number);
+/**
+ * Denotes a simple string to string dictionary.
+ *
+ * @export
+ * @type Options
+ */
+export declare type StringDictionary = {
+    [key: string]: string;
+};
 //# sourceMappingURL=type-declarations.d.ts.map

package/src/type-declarations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type-declarations.d.ts","sourceRoot":"","sources":["type-declarations.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,MAAO,SAAQ,YAAY;CAAG;AAE3C;;;;;;GAMG;AACH,qBAAa,MAAO,SAAQ,KAAK,CAAC,MAAM,CAAC;CAAG;AAE5C;;;;;;GAMG;AACH,qBAAa,WAAY,SAAQ,MAAM;CAAG;AAE1C;;;;;;GAMG;AACH,qBAAa,OAAQ,SAAQ,KAAK,CAAC,GAAG,CAAC;CAAG;AAE1C;;;;;GAKG;AACH,oBAAY,OAAO,GAAG;IAAC,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,CAAC;AAE5C;;;;;;;;GAQG;AACF,oBAAY,cAAc,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC"}
+{"version":3,"file":"type-declarations.d.ts","sourceRoot":"","sources":["type-declarations.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,MAAO,SAAQ,YAAY;CAAG;AAE3C;;;;;;GAMG;AACH,qBAAa,MAAO,SAAQ,KAAK,CAAC,MAAM,CAAC;CAAG;AAE5C;;;;;;GAMG;AACH,qBAAa,WAAY,SAAQ,MAAM;CAAG;AAE1C;;;;;;GAMG;AACH,qBAAa,OAAQ,SAAQ,KAAK,CAAC,GAAG,CAAC;CAAG;AAE1C;;;;;GAKG;AACH,oBAAY,OAAO,GAAG;IAAC,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,CAAC;AAE5C;;;;;;;;GAQG;AACF,oBAAY,cAAc,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;AAE7D;;;;;GAKG;AACF,oBAAY,gBAAgB,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAC,CAAC"}

package/src/type-declarations.js

@@ -34,4 +34,4 @@ export class Coordinates extends Matrix {
  */
 export class Vectors extends Array {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZS1kZWNsYXJhdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0eXBlLWRlY2xhcmF0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFDSCxNQUFNLE9BQU8sTUFBTyxTQUFRLFlBQVk7Q0FBRztBQUUzQzs7Ozs7O0dBTUc7QUFDSCxNQUFNLE9BQU8sTUFBTyxTQUFRLEtBQWE7Q0FBRztBQUU1Qzs7Ozs7O0dBTUc7QUFDSCxNQUFNLE9BQU8sV0FBWSxTQUFRLE1BQU07Q0FBRztBQUUxQzs7Ozs7O0dBTUc7QUFDSCxNQUFNLE9BQU8sT0FBUSxTQUFRLEtBQVU7Q0FBRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRGVub3RlcyBhIHZlY3RvciBvZiBmbG9hdGluZyBwb2l0IHZhbHVlcy5cbiAqXG4gKiBAZXhwb3J0XG4gKiBAY2xhc3MgVmVjdG9yXG4gKiBAZXh0ZW5kcyB7RmxvYXQzMkFycmF5fVxuICovXG5leHBvcnQgY2xhc3MgVmVjdG9yIGV4dGVuZHMgRmxvYXQzMkFycmF5IHt9XG5cbi8qKlxuICogRGVub3RlcyBhIHR3by1kaW1lbnNpb25hbCBtYXRyaXguXG4gKlxuICogQGV4cG9ydFxuICogQGNsYXNzIE1hdHJpeFxuICogQGV4dGVuZHMge0FycmF5PFZlY3Rvcj59XG4gKi9cbmV4cG9ydCBjbGFzcyBNYXRyaXggZXh0ZW5kcyBBcnJheTxWZWN0b3I+IHt9XG5cbi8qKlxuICogRGVub3RlcyBjYXJ0ZXNpYW4gY29vcmRpbmF0ZXMuXG4gKlxuICogQGV4cG9ydFxuICogQGNsYXNzIENvb3JkaW5hdGVzXG4gKiBAZXh0ZW5kcyB7TWF0cml4fVxuICovXG5leHBvcnQgY2xhc3MgQ29vcmRpbmF0ZXMgZXh0ZW5kcyBNYXRyaXgge31cblxuLyoqXG4gKiBEZW5vdGVzIGFuIGFycmF5IG9mIGFyYml0cmFyeS10eXBlZCB2ZWN0b3JzLlxuICpcbiAqIEBleHBvcnRcbiAqIEBjbGFzcyBWZWN0b3JzXG4gKiBAZXh0ZW5kcyB7QXJyYXk8YW55Pn1cbiAqL1xuZXhwb3J0IGNsYXNzIFZlY3RvcnMgZXh0ZW5kcyBBcnJheTxhbnk+IHt9XG5cbi8qKlxuICogRGVub3RlcyBhIGRpY3Rpb25hcnkgY29udGFpbmluZyBmdW5jdGlvbiBvcHRpb25zLlxuICpcbiAqIEBleHBvcnRcbiAqIEB0eXBlIE9wdGlvbnNcbiAqL1xuZXhwb3J0IHR5cGUgT3B0aW9ucyA9IHtbbmFtZTogc3RyaW5nXTogYW55fTtcblxuLyoqXG4gKiBEZW5vdGVzIGN1c3RvbSBkaXN0YW5jZSBtZXRyaWMgYmV0d2VlbiB0aGUgdHdvIGdpdmVuIHZlY3RvcnMuXG4gKlxuICogQGV4cG9ydFxuICogQHR5cGUgRGlzdGFuY2VNZXRyaWNcbiAqIEBwYXJhbSB7YW55fSB2MSBUaGUgZmlyc3QgdmVjdG9yLlxuICogQHBhcmFtIHthbnl9IHYyIFRoZSBzZWNvbmQgdmVjdG9yLlxuICogQHJldHVybiB7bnVtYmVyfSBEaXN0YW5jZSBiZXR3ZWVuIHRoZXNlIHR3byB2ZWN0b3JzLlxuICovXG4gZXhwb3J0IHR5cGUgRGlzdGFuY2VNZXRyaWMgPSAodjE6IGFueSwgdjI6IGFueSkgPT4gKG51bWJlcik7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZS1kZWNsYXJhdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0eXBlLWRlY2xhcmF0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFDSCxNQUFNLE9BQU8sTUFBTyxTQUFRLFlBQVk7Q0FBRztBQUUzQzs7Ozs7O0dBTUc7QUFDSCxNQUFNLE9BQU8sTUFBTyxTQUFRLEtBQWE7Q0FBRztBQUU1Qzs7Ozs7O0dBTUc7QUFDSCxNQUFNLE9BQU8sV0FBWSxTQUFRLE1BQU07Q0FBRztBQUUxQzs7Ozs7O0dBTUc7QUFDSCxNQUFNLE9BQU8sT0FBUSxTQUFRLEtBQVU7Q0FBRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRGVub3RlcyBhIHZlY3RvciBvZiBmbG9hdGluZyBwb2l0IHZhbHVlcy5cbiAqXG4gKiBAZXhwb3J0XG4gKiBAY2xhc3MgVmVjdG9yXG4gKiBAZXh0ZW5kcyB7RmxvYXQzMkFycmF5fVxuICovXG5leHBvcnQgY2xhc3MgVmVjdG9yIGV4dGVuZHMgRmxvYXQzMkFycmF5IHt9XG5cbi8qKlxuICogRGVub3RlcyBhIHR3by1kaW1lbnNpb25hbCBtYXRyaXguXG4gKlxuICogQGV4cG9ydFxuICogQGNsYXNzIE1hdHJpeFxuICogQGV4dGVuZHMge0FycmF5PFZlY3Rvcj59XG4gKi9cbmV4cG9ydCBjbGFzcyBNYXRyaXggZXh0ZW5kcyBBcnJheTxWZWN0b3I+IHt9XG5cbi8qKlxuICogRGVub3RlcyBjYXJ0ZXNpYW4gY29vcmRpbmF0ZXMuXG4gKlxuICogQGV4cG9ydFxuICogQGNsYXNzIENvb3JkaW5hdGVzXG4gKiBAZXh0ZW5kcyB7TWF0cml4fVxuICovXG5leHBvcnQgY2xhc3MgQ29vcmRpbmF0ZXMgZXh0ZW5kcyBNYXRyaXgge31cblxuLyoqXG4gKiBEZW5vdGVzIGFuIGFycmF5IG9mIGFyYml0cmFyeS10eXBlZCB2ZWN0b3JzLlxuICpcbiAqIEBleHBvcnRcbiAqIEBjbGFzcyBWZWN0b3JzXG4gKiBAZXh0ZW5kcyB7QXJyYXk8YW55Pn1cbiAqL1xuZXhwb3J0IGNsYXNzIFZlY3RvcnMgZXh0ZW5kcyBBcnJheTxhbnk+IHt9XG5cbi8qKlxuICogRGVub3RlcyBhIGRpY3Rpb25hcnkgY29udGFpbmluZyBmdW5jdGlvbiBvcHRpb25zLlxuICpcbiAqIEBleHBvcnRcbiAqIEB0eXBlIE9wdGlvbnNcbiAqL1xuZXhwb3J0IHR5cGUgT3B0aW9ucyA9IHtbbmFtZTogc3RyaW5nXTogYW55fTtcblxuLyoqXG4gKiBEZW5vdGVzIGN1c3RvbSBkaXN0YW5jZSBtZXRyaWMgYmV0d2VlbiB0aGUgdHdvIGdpdmVuIHZlY3RvcnMuXG4gKlxuICogQGV4cG9ydFxuICogQHR5cGUgRGlzdGFuY2VNZXRyaWNcbiAqIEBwYXJhbSB7YW55fSB2MSBUaGUgZmlyc3QgdmVjdG9yLlxuICogQHBhcmFtIHthbnl9IHYyIFRoZSBzZWNvbmQgdmVjdG9yLlxuICogQHJldHVybiB7bnVtYmVyfSBEaXN0YW5jZSBiZXR3ZWVuIHRoZXNlIHR3byB2ZWN0b3JzLlxuICovXG4gZXhwb3J0IHR5cGUgRGlzdGFuY2VNZXRyaWMgPSAodjE6IGFueSwgdjI6IGFueSkgPT4gKG51bWJlcik7XG5cbi8qKlxuICogRGVub3RlcyBhIHNpbXBsZSBzdHJpbmcgdG8gc3RyaW5nIGRpY3Rpb25hcnkuXG4gKlxuICogQGV4cG9ydFxuICogQHR5cGUgT3B0aW9uc1xuICovXG4gZXhwb3J0IHR5cGUgU3RyaW5nRGljdGlvbmFyeSA9IHtba2V5OiBzdHJpbmddOiBzdHJpbmd9OyJdfQ==