@datagrok-libraries/utils 0.0.13 → 0.0.18

package/package.json

@@ -1,29 +1,25 @@
 {
-	"name": "@datagrok-libraries/utils",
-	"publishConfig": {
-		"access": "public"
-	},
-	"fullName": "Utils",
-	"version": "0.0.13",
-	"description": "Common utilities",
-	"dependencies": {
-		"@keckelt/tsne": "^1.0.2",
-		"@types/node": "^14.14.37",
-		"datagrok-api": ">=0.95.8",
-		"dts-bundle": "^0.7.3",
-		"fastest-levenshtein": "^1.0.12",
-		"jaro-winkler-typescript": "^1.0.1",
-		"umap-js": "^1.3.3",
-		"js-yaml": "^4.1.0",
-		"node-fetch": "^2.6.0"
-	},
-	"devDependencies": {
-		"typescript": "^4.2.3",
-		"ts-loader": "^9.2.6"
-	},
-	"scripts": {
-		"link": "npm link",
-		"link-api": "npm link datagrok-api",
-		"build": "tsc"
-	}
+  "name": "@datagrok-libraries/utils",
+  "publishConfig": {
+    "access": "public"
+  },
+  "fullName": "Utils",
+  "version": "0.0.18",
+  "description": "Common utilities",
+  "dependencies": {
+    "@types/node": "^14.14.37",
+    "datagrok-api": ">=0.95.8",
+    "dts-bundle": "^0.7.3",
+    "js-yaml": "^4.1.0",
+    "node-fetch": "^2.6.0"
+  },
+  "devDependencies": {
+    "typescript": "^4.2.3",
+    "ts-loader": "^9.2.6"
+  },
+  "scripts": {
+    "link": "npm link",
+    "link-api": "npm link datagrok-api",
+    "build": "tsc"
+  }
 }

package/src/operations.d.ts

@@ -63,6 +63,8 @@ export declare function calculateEuclideanDistance(p: Vector, q: Vector): number
  * @return {Matrix} Calculated custom distance matrix.
  */
 export declare function calcDistanceMatrix(data: Vectors, distance: DistanceMetric): Matrix;
+/** Generates array from a range [begin; end] or [begin; end) if endExclusive. */
+export declare function genRange(begin: number, end: number, endExclusive?: boolean): Int32Array;
 /**
  * Returns order of values as if they are sorted.
  *

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;;;;;;;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"}

package/src/operations.js

@@ -141,6 +141,15 @@ export function calcDistanceMatrix(data, distance) {
     }
     return matrix;
 }
+/** Generates array from a range [begin; end] or [begin; end) if endExclusive. */
+export function genRange(begin, end, endExclusive = false) {
+    const nItems = end - begin + (endExclusive ? 0 : 1);
+    const series = new Int32Array(nItems);
+    for (let i = 0; i < nItems; ++i) {
+        series[i] = begin + i;
+    }
+    return series;
+}
 /**
  * Returns order of values as if they are sorted.
  *
@@ -156,4 +165,4 @@ 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/**\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"]}
+//# 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"]}

package/src/{test-utils.d.ts → test-node.d.ts}

@@ -8,4 +8,4 @@ export declare function getBrowserPage(puppeteer: any): Promise<{
     browser: any;
     page: any;
 }>;
-//# sourceMappingURL=test-utils.d.ts.map
+//# sourceMappingURL=test-node.d.ts.map

package/src/test-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-node.d.ts","sourceRoot":"","sources":["test-node.ts"],"names":[],"mappings":"AAOA,wBAAsB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,gBAOtD;AAED,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,gBAIzD;AAaD,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAC,CAkBrE;AAED,wBAAsB,cAAc,CAAC,SAAS,EAAE,GAAG,GAAG,OAAO,CAAC;IAAC,OAAO,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,GAAG,CAAA;CAAC,CAAC,CA8BvF"}

package/src/test-node.js

@@ -0,0 +1,96 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as path from "path";
+import * as os from "os";
+import * as fs from "fs";
+// @ts-ignore
+import * as yaml from 'js-yaml';
+const fetch = require('node-fetch');
+export function getToken(url, key) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let response = yield fetch(`${url}/users/login/dev/${key}`, { method: 'POST' });
+        let json = yield response.json();
+        if (json.isSuccess == true)
+            return json.token;
+        else
+            throw 'Unable to login to server. Check your dev key';
+    });
+}
+export function getWebUrl(url, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let response = yield fetch(`${url}/admin/plugins/admin/settings`, { headers: { Authorization: token } });
+        let json = yield response.json();
+        return json.settings.webRoot;
+    });
+}
+const grokDir = path.join(os.homedir(), '.grok');
+const confPath = path.join(grokDir, 'config.yaml');
+function mapURL(conf) {
+    let urls = {};
+    for (let server in conf.servers) {
+        urls[conf['servers'][server]['url']] = conf['servers'][server];
+    }
+    return urls;
+}
+export function getDevKey(hostKey) {
+    let config = yaml.load(fs.readFileSync(confPath, 'utf8'));
+    let host = hostKey == '' ? config.default : hostKey;
+    host = host.trim();
+    let urls = mapURL(config);
+    let key = '';
+    let url = '';
+    try {
+        let url = new URL(host).href;
+        if (url.endsWith('/'))
+            url = url.slice(0, -1);
+        if (url in urls)
+            key = config['servers'][urls[url]]['key'];
+    }
+    catch (error) {
+        if (config['servers'][host] == null)
+            throw `Unknown server alias. Please add it to ${confPath}`;
+        url = config['servers'][host]['url'];
+        key = config['servers'][host]['key'];
+    }
+    return { url, key };
+}
+export function getBrowserPage(puppeteer) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        let url = (_a = process.env.HOST) !== null && _a !== void 0 ? _a : '';
+        let cfg = getDevKey(url);
+        url = cfg.url;
+        let key = cfg.key;
+        let token = yield getToken(url, key);
+        url = yield getWebUrl(url, token);
+        console.log(`Using web root: ${url}`);
+        let browser = yield puppeteer.launch({
+            args: ['--disable-dev-shm-usage', '--disable-features=site-per-process'],
+            ignoreHTTPSErrors: true,
+        });
+        let page = yield browser.newPage();
+        yield page.goto(`${url}/oauth/`);
+        yield page.setCookie({ name: 'auth', value: token });
+        yield page.evaluate((token) => {
+            window.localStorage.setItem('auth', token);
+        }, token);
+        yield page.goto(url);
+        try {
+            yield page.waitForSelector('.grok-preloader');
+            console.log('got preloader');
+            yield page.waitForFunction(() => document.querySelector('.grok-preloader') == null, { timeout: 100000 });
+        }
+        catch (error) {
+            throw error;
+        }
+        return { browser, page };
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-node.js","sourceRoot":"","sources":["test-node.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from \"path\";\nimport * as os from \"os\";\nimport * as fs from \"fs\";\n// @ts-ignore\nimport * as yaml from 'js-yaml';\nconst fetch = require('node-fetch');\n\nexport async function getToken(url: string, key: string) {\n  let response = await fetch(`${url}/users/login/dev/${key}`, {method: 'POST'});\n  let json = await response.json();\n  if (json.isSuccess == true)\n    return json.token;\n  else\n    throw 'Unable to login to server. Check your dev key';\n}\n\nexport async function getWebUrl(url: string, token: string) {\n  let response = await fetch(`${url}/admin/plugins/admin/settings`, {headers: {Authorization: token}});\n  let json = await response.json();\n  return json.settings.webRoot;\n}\n\nconst grokDir = path.join(os.homedir(), '.grok');\nconst confPath = path.join(grokDir, 'config.yaml');\n\nfunction mapURL(conf: Config): Indexable {\n  let urls: Indexable = {};\n  for (let server in conf.servers) {\n    urls[conf['servers'][server]['url']] = conf['servers'][server];\n  }\n  return urls;\n}\n\nexport function getDevKey(hostKey: string): {url: string, key: string} {\n  let config = yaml.load(fs.readFileSync(confPath, 'utf8')) as any;\n  let host = hostKey == '' ? config.default : hostKey;\n  host = host.trim();\n  let urls = mapURL(config);\n  let key = '';\n  let url = '';\n  try {\n    let url = new URL(host).href;\n    if (url.endsWith('/')) url = url.slice(0, -1);\n    if (url in urls) key = config['servers'][urls[url]]['key'];\n  } catch (error) {\n    if (config['servers'][host] == null)\n      throw `Unknown server alias. Please add it to ${confPath}`;\n    url = config['servers'][host]['url'];\n    key = config['servers'][host]['key'];\n  }\n  return {url, key};\n}\n\nexport async function getBrowserPage(puppeteer: any): Promise<{browser: any, page: any}> {\n  let url:string = process.env.HOST ?? '';\n  let cfg = getDevKey(url);\n  url = cfg.url;\n\n  let key = cfg.key;\n  let token = await getToken(url, key);\n  url = await getWebUrl(url, token);\n  console.log(`Using web root: ${url}`);\n\n  let browser = await puppeteer.launch({\n    args: ['--disable-dev-shm-usage', '--disable-features=site-per-process'],\n    ignoreHTTPSErrors: true,\n  });\n\n  let page = await browser.newPage();\n  await page.goto(`${url}/oauth/`);\n  await page.setCookie({name: 'auth', value: token});\n  await page.evaluate((token: any) => {\n    window.localStorage.setItem('auth', token);\n  }, token);\n  await page.goto(url);\n  try {\n    await page.waitForSelector('.grok-preloader');\n    console.log('got preloader');\n    await page.waitForFunction(() => document.querySelector('.grok-preloader') == null, {timeout: 100000});\n  } catch (error) {\n    throw error;\n  }\n  return {browser, page};\n}\n\n\ninterface Config {\n  servers: {\n    [alias: string]: {\n      url: string,\n      key: string\n    }\n  },\n  default: string,\n}\n\ninterface Indexable { [key: string]: any }\n"]}

package/src/test.d.ts

@@ -0,0 +1,36 @@
+export declare let tests: {
+    [key: string]: {
+        tests?: Test[];
+        before?: () => Promise<void>;
+        after?: () => Promise<void>;
+        beforeStatus?: string;
+        afterStatus?: string;
+    };
+};
+export declare let currentCategory: string;
+export declare class Test {
+    test: () => Promise<any>;
+    name: string;
+    category: string;
+    constructor(category: string, name: string, test: () => Promise<any>);
+}
+export declare function test(name: string, test: () => Promise<any>): void;
+/** Tests two objects for equality, throws an exception if they are not equal. */
+export declare function expect(actual: any, expected: any): 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. */
+export declare function before(before: () => Promise<void>): void;
+/** Defines a function to be executed after the tests in this category are executed. */
+export declare function after(after: () => Promise<void>): void;
+export declare function runTests(options?: {
+    category?: string;
+    test?: string;
+}): Promise<{
+    category?: string | undefined;
+    name?: string | undefined;
+    success: boolean;
+    result: string;
+}[]>;
+export declare function delay(ms: number): Promise<void>;
+//# sourceMappingURL=test.d.ts.map

package/src/test.d.ts.map

@@ -0,0 +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"}

package/src/test.js

@@ -0,0 +1,109 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export let tests = {};
+export let currentCategory;
+export class Test {
+    constructor(category, name, test) {
+        this.category = category;
+        this.name = name;
+        this.test = test;
+    }
+}
+export function test(name, test) {
+    if (tests[currentCategory] == undefined)
+        tests[currentCategory] = {};
+    if (tests[currentCategory].tests == undefined)
+        tests[currentCategory].tests = [];
+    tests[currentCategory].tests.push(new Test(currentCategory, name, test));
+}
+/** 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}"`;
+}
+/** Defines a test suite. */
+export function category(category, tests) {
+    currentCategory = category;
+    tests();
+}
+/** Defines a function to be executed before the tests in this category are executed. */
+export function before(before) {
+    if (tests[currentCategory] == undefined)
+        tests[currentCategory] = {};
+    tests[currentCategory].before = before;
+}
+/** Defines a function to be executed after the tests in this category are executed. */
+export function after(after) {
+    if (tests[currentCategory] == undefined)
+        tests[currentCategory] = {};
+    tests[currentCategory].after = after;
+}
+export function runTests(options) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        let results = [];
+        for (const [key, value] of Object.entries(tests)) {
+            if ((options === null || options === void 0 ? void 0 : options.category) != undefined) {
+                if (!key.toLowerCase().startsWith(options === null || options === void 0 ? void 0 : options.category.toLowerCase()))
+                    continue;
+            }
+            try {
+                if (value.before)
+                    yield value.before();
+            }
+            catch (x) {
+                value.beforeStatus = x.toString();
+            }
+            let t = (_a = value.tests) !== null && _a !== void 0 ? _a : [];
+            let res = [];
+            for (let i = 0; i < t.length; i++) {
+                res.push(yield execTest(t[i], options === null || options === void 0 ? void 0 : options.test));
+            }
+            let data = (yield Promise.all(res)).filter((d) => d.result != 'skipped');
+            try {
+                if (value.after)
+                    yield value.after();
+            }
+            catch (x) {
+                value.afterStatus = x.toString();
+            }
+            if (value.afterStatus)
+                data.push({ category: key, name: 'init', result: value.afterStatus, success: false });
+            if (value.beforeStatus)
+                data.push({ category: key, name: 'init', result: value.beforeStatus, success: false });
+            results.push(...data);
+        }
+        return results;
+    });
+}
+function execTest(t, predicate) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        let r;
+        try {
+            if (predicate != undefined && (!t.name.toLowerCase().startsWith(predicate.toLowerCase())))
+                r = { success: true, result: 'skipped' };
+            else
+                r = { success: true, result: (_a = yield t.test()) !== null && _a !== void 0 ? _a : 'OK' };
+        }
+        catch (x) {
+            r = { success: false, result: x.toString() };
+        }
+        r.category = t.category;
+        r.name = t.name;
+        return r;
+    });
+}
+export function delay(ms) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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"]}

package/tsconfig.json

@@ -4,7 +4,7 @@
 
     /* Basic Options */
     // "incremental": true,                         /* Enable incremental compilation */
-    "target": "es2018",                                /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+    "target": "es6",                                /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
     "module": "es2020",                             /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
     "lib": ["es2020", "dom"],                       /* Specify library files to be included in the compilation. */
     // "allowJs": true,                             /* Allow javascript files to be compiled. */

package/src/reduce-dimensionality.d.ts

@@ -1,38 +0,0 @@
-import { Options, Coordinates } from './type-declarations';
-/**
- * Unified class implementing different dimensionality reduction methods.
- *
- * @export
- * @class DimensionalityReducer
- */
-export declare class DimensionalityReducer {
-    private reducer;
-    static methods: string[];
-    private measurer;
-    /**
-     * Creates an instance of DimensionalityReducer.
-     * @param {any[]} data Vectors to embed.
-     * @param {string} method Embedding method to be applied
-     * @param {string} metric Distance metric to be computed between each of the vectors.
-     * @param {Options} [options] Options to pass to the implementing embedders.
-     * @memberof DimensionalityReducer
-     */
-    constructor(data: any[], method: string, metric: string, options?: Options);
-    /**
-     * Embeds the data given into the two-dimensional space using the chosen method.
-     *
-     * @param {boolean} transpose Whether to transform coordinates to have columns-first orientation.
-     * @throws {Error} If the embedding method was not found.
-     * @return {Coordinates} Cartesian coordinate of this embedding.
-     * @memberof DimensionalityReducer
-     */
-    transform(transpose?: boolean): Coordinates;
-    /**
-     * Returns dimensionality reduction methods available.
-     *
-     * @readonly
-     * @memberof DimensionalityReducer
-     */
-    static get availableMethods(): string[];
-}
-//# sourceMappingURL=reduce-dimensionality.d.ts.map

package/src/reduce-dimensionality.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reduce-dimensionality.d.ts","sourceRoot":"","sources":["reduce-dimensionality.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,OAAO,EAAkB,WAAW,EAA0B,MAAM,qBAAqB,CAAC;AAuMlG;;;;;GAKG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAc,OAAO,EAAE,MAAM,EAAE,CAAoC;IACnE,OAAO,CAAC,QAAQ,CAAW;IAE3B;;;;;;;OAOG;gBACS,IAAI,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO;IA2B1E;;;;;;;OAOG;IACI,SAAS,CAAC,SAAS,GAAE,OAAe,GAAG,WAAW;IAYzD;;;;;OAKG;IACH,MAAM,KAAK,gBAAgB,aAE1B;CACF"}