@dotglitch/ngx-common 1.0.2

package/esm2020/services/dependency.service.mjs

@@ -0,0 +1,55 @@
+import { DOCUMENT } from '@angular/common';
+import { Injectable, Inject } from '@angular/core';
+import { sleep } from '../utils';
+import * as i0 from "@angular/core";
+const SCRIPT_INIT_TIMEOUT = 500; // ms
+/**
+ * Service that installs CSS/JS dynamically
+ */
+export class DependencyService {
+    constructor(document) {
+        this.document = document;
+    }
+    /**
+     * Install a Javascript file into the webpage on-demand
+     * @param id Unique identifier for the JS script
+     * @param src URL of the script
+     * @param globalkey A global object the script will provide.
+     *  Providing this will ensure a promise only resolves after the
+     *  specified global object is provided, with a timeout of 500ms
+     */
+    loadScript(id, src, globalkey = null) {
+        return new Promise((res, rej) => {
+            if (this.document.getElementById(id))
+                return res();
+            const script = this.document.createElement('script');
+            script.id = id;
+            script.setAttribute("async", '');
+            script.setAttribute("src", src);
+            script.onload = async () => {
+                if (typeof globalkey == "string") {
+                    let i = 0;
+                    for (; !window[globalkey] && i < SCRIPT_INIT_TIMEOUT; i += 10)
+                        await sleep(10);
+                    if (i >= SCRIPT_INIT_TIMEOUT) {
+                        return rej(new Error("Timed out waiting for script to self-initialize."));
+                    }
+                }
+                res();
+            };
+            this.document.body.appendChild(script);
+        });
+    }
+}
+DependencyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DependencyService, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+DependencyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DependencyService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DependencyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/dialog.service.mjs

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+import { Logger } from '../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "../public-api";
+const { log, warn, err } = Logger("DialogService", "#607d8b");
+export class DialogService {
+    constructor(dialog, lazyLoader) {
+        this.dialog = dialog;
+        this.lazyLoader = lazyLoader;
+        this.dialogs = [];
+    }
+    open(name, opts = {}) {
+        return new Promise((resolve, reject) => {
+            const registration = this.lazyLoader.resolveRegistrationEntry(name, opts.group || "default");
+            if (!registration)
+                return reject(new Error("Cannot open dialog for " + name + ". Could not find in registry."));
+            const args = {
+                closeOnNavigation: true,
+                restoreFocus: true,
+                width: registration['width'],
+                height: registration['height'],
+                ...opts,
+                data: {
+                    id: name,
+                    inputs: opts.inputs || {},
+                    outputs: opts.outputs || {},
+                    group: opts.group
+                },
+                panelClass: [
+                    "dialog-" + name,
+                    ...(Array.isArray(opts.panelClass) ? opts.panelClass : [opts.panelClass] || [])
+                ]
+            };
+            // TODO:
+            let dialog = this.dialog.open(undefined, args);
+            dialog['idx'] = name;
+            this.dialogs.push(dialog);
+            dialog.afterClosed().subscribe(result => {
+                log("Dialog closed " + name, result);
+                resolve(result);
+            });
+        });
+    }
+    // Close all dialogs matching the given name
+    close(name) {
+        const dialogs = this.dialogs.filter(d => d['idx'] == name);
+        dialogs.forEach(dialog => dialog.close());
+    }
+    /**
+     * Method to close _all_ dialogs.
+     * Should be used sparingly.
+     */
+    clearDialog() {
+        this.dialogs.forEach(dialog => dialog.close());
+    }
+}
+DialogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DialogService, deps: [{ token: i1.MatDialog }, { token: i2.LazyLoaderService }], target: i0.ɵɵFactoryTarget.Injectable });
+DialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DialogService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }, { type: i2.LazyLoaderService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/fetch.service.mjs

@@ -0,0 +1,71 @@
+import { Injectable, isDevMode } from '@angular/core';
+import { retry } from 'rxjs/operators';
+import { of } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+// Total number of _retries_ if there is a 429 response code.
+const retryCount = 2;
+export class Fetch {
+    constructor(http) {
+        this.http = http;
+    }
+    // Public interface for making AJAX transactions
+    get(url, options = {}, returnError = false) {
+        return this.request("get", url, options, returnError);
+    }
+    put(url, body, options = {}, returnError = false) {
+        options.body = (options.body && Object.keys(options.body).length > 0 ? options.body : body) || {};
+        return this.request("put", url, options, returnError);
+    }
+    post(url, body, options = {}, returnError = false) {
+        options.body = (options.body && Object.keys(options.body).length > 0 ? options.body : body) || {};
+        return this.request("post", url, options, returnError);
+    }
+    patch(url, body, options = {}, returnError = false) {
+        options.body = (options.body && Object.keys(options.body).length > 0 ? options.body : body) || {};
+        return this.request("patch", url, options, returnError);
+    }
+    delete(url, options = {}, returnError = false) {
+        return this.request("delete", url, options, returnError);
+    }
+    // Internally, handle the observable as a promise.
+    request(method, url, options = {}, returnError = false) {
+        options.reportProgress = true;
+        // Allow support for different response types.
+        // Generally we shouldn't need this to be anything other than JSON.
+        options.responseType = options.responseType || "json";
+        options.withCredentials = true;
+        const p = new Promise((resolve, reject) => {
+            const o = this.http.request(method, url, options)
+                .pipe(retry({
+                delay(error, retryCount) {
+                    // 429 and 502 are most common for overloaded
+                    // backends -- so we'll retry if we get these errors
+                    if (error.status == 429 || error.status == 502)
+                        return of({});
+                    if (error.status == 504 && isDevMode())
+                        alert("It looks like you can't reach your development backend anymore");
+                    throw error;
+                },
+                count: retryCount
+            }))
+                .subscribe(data => {
+                resolve(data);
+                // provide 3ms slacktime before releasing observable.
+                setTimeout(() => {
+                    o.unsubscribe();
+                }, 3);
+            });
+        });
+        return p;
+    }
+}
+Fetch.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: Fetch, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+Fetch.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: Fetch, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: Fetch, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fetch.service.js","sourceRoot":"","sources":["../../../../packages/common/src/services/fetch.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpContext, HttpHeaders, HttpParams } from \"@angular/common/http\";\nimport { Injectable, isDevMode } from '@angular/core';\nimport { retry } from 'rxjs/operators';\nimport { of } from 'rxjs';\n\n// Total number of _retries_ if there is a 429 response code.\nconst retryCount = 2;\n\nexport type FetchOptions = {\n    headers?: HttpHeaders | {\n        [header: string]: string | string[];\n    };\n    context?: HttpContext;\n    params?: HttpParams | {\n        [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;\n    };\n    body?: any,\n    observe?: 'body' | 'events' | 'response';\n    reportProgress?: boolean;\n    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n    withCredentials?: boolean;\n}\n\n@Injectable({\n    providedIn: \"root\"\n})\nexport class Fetch {\n    constructor(\n        private http: HttpClient\n    ) { }\n\n    // Public interface for making AJAX transactions\n    public get<T>(url: string, options: FetchOptions = {}, returnError = false): Promise<T> {\n        return this.request<T>(\"get\", url, options, returnError);\n    }\n    public put<T>(url: string, body: any, options: FetchOptions = {}, returnError = false): Promise<T> {\n        options.body = (options.body && Object.keys(options.body).length > 0 ? options.body : body) || {};\n        return this.request<T>(\"put\", url, options, returnError);\n    }\n    public post<T>(url: string, body: any, options: FetchOptions = {}, returnError = false): Promise<T> {\n        options.body = (options.body && Object.keys(options.body).length > 0 ? options.body : body) || {};\n        return this.request<T>(\"post\", url, options, returnError);\n    }\n    public patch<T>(url: string, body: any, options: FetchOptions = {}, returnError = false): Promise<T> {\n        options.body = (options.body && Object.keys(options.body).length > 0 ? options.body : body) || {};\n        return this.request<T>(\"patch\", url, options, returnError);\n    }\n    public delete<T>(url: string, options: FetchOptions = {}, returnError = false): Promise<T> {\n        return this.request<T>(\"delete\", url, options, returnError);\n    }\n\n    // Internally, handle the observable as a promise.\n    private request<T>(method: string, url: string, options: FetchOptions = {}, returnError = false): Promise<T> {\n        options.reportProgress = true;\n\n        // Allow support for different response types.\n        // Generally we shouldn't need this to be anything other than JSON.\n        options.responseType = options.responseType || \"json\";\n        options.withCredentials = true;\n\n        const p = new Promise((resolve, reject) => {\n            const o = this.http.request(method, url, options)\n                .pipe(retry({\n                    delay(error, retryCount) {\n                        // 429 and 502 are most common for overloaded\n                        // backends -- so we'll retry if we get these errors\n                        if (error.status == 429 || error.status == 502)\n                            return of({});\n\n                        if (error.status == 504 && isDevMode())\n                            alert(\"It looks like you can't reach your development backend anymore\");\n\n                        throw error;\n                    },\n                    count: retryCount\n                }))\n                .subscribe(data => {\n                    resolve(data as unknown as T);\n\n                    // provide 3ms slacktime before releasing observable.\n                    setTimeout(() => {\n                        o.unsubscribe();\n                    }, 3);\n                });\n        });\n\n        return p as Promise<T>;\n    }\n}\n"]}

package/esm2020/services/keyboard.service.mjs

@@ -0,0 +1,128 @@
+import { Injectable, HostListener } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Service that listens for global keyboard events
+ */
+export class KeyboardService {
+    constructor() {
+        this.heldKeys = {};
+        this.keyCommands = [];
+        window.addEventListener("keydown", (evt) => this.onKeyDown(evt));
+        window.addEventListener("keyup", (evt) => this.onKeyUp(evt));
+    }
+    onKeyDown(evt) {
+        // console.log("keydown", evt.key)
+        this.heldKeys[evt.key.toLowerCase()] = true;
+        // Do a general filter where all of the modifiers must be matched if specified
+        // Then check that the actual keys match what was specified
+        let commands = this.keyCommands
+            .filter(kc => (kc.ctrl == undefined || kc.ctrl === evt.ctrlKey) &&
+            (kc.alt == undefined || kc.alt === evt.altKey) &&
+            (kc.shift == undefined || kc.shift === evt.shiftKey) &&
+            (kc.super == undefined || kc.super === evt.metaKey) &&
+            kc.keys.length == kc.keys.filter(k => this.heldKeys[k])?.length);
+        if (evt.ctrlKey && commands.length > 0 || commands.find(c => c.interrupt)) {
+            evt.stopPropagation();
+            evt.preventDefault();
+        }
+        if (evt.key == "Pause")
+            debugger;
+        commands.forEach(kc => kc.sub.next(evt));
+        /**
+         * Prevent CTRL+P and other standard key events from being handled by the browser.
+         * Allow specific combonations:
+         * CTRL+W
+         * CTRL+T
+         * CTRL+F5
+         */
+        // if (evt.ctrlKey && !['w', 't', 'F5'].includes(evt.key)) {
+        //     evt.preventDefault();
+        // }
+    }
+    onKeyUp(evt) {
+        this.heldKeys[evt.key.toLowerCase()] = false;
+    }
+    onKeyPress(evt) {
+        // this.heldKeys[evt.key] = false;
+    }
+    /**
+     * Use this to subscribe to keyboard events throughout
+     * the application. This is a passive listener and will
+     * **NOT** interrupt the event chain.
+     */
+    onKeyCommand(key) {
+        const sub = new Subject();
+        let item = {
+            ...key,
+            keys: (Array.isArray(key.key) ? key.key : [key.key]),
+            sub: sub
+        };
+        this.keyCommands.push(item);
+        return {
+            ...sub,
+            subscribe: ((...args) => {
+                const s = sub.subscribe(...args);
+                return {
+                    ...s,
+                    unsubscribe: () => {
+                        s.unsubscribe();
+                        // Remove the keycommand from the list of listeners.
+                        const i = this.keyCommands.findIndex(c => c == item);
+                        this.keyCommands.splice(i, 1);
+                    }
+                };
+            })
+        };
+    }
+    /**
+     * Return `true` if shift is currently pressed.
+     */
+    get isShiftPressed() {
+        return !!this.heldKeys["shift"];
+    }
+    /**
+     * Return `true` if ctrl is currently pressed.
+     */
+    get isCtrlPressed() {
+        return !!this.heldKeys["control"];
+    }
+    /**
+     * Return `true` if alt is currently pressed.
+     */
+    get isAltPressed() {
+        return !!this.heldKeys["alt"];
+    }
+    /**
+     * Return `true` if super (mac/linux) or the windows key is currently pressed.
+     */
+    get isSuperPressed() {
+        return !!this.heldKeys["super"];
+    }
+    /**
+     * Return `true` if tab is currently pressed.
+     */
+    get isTabPressed() {
+        return !!this.heldKeys["tab"];
+    }
+    clearKeys() {
+        Object.keys(this.heldKeys).forEach(k => {
+            this.heldKeys[k] = false;
+        });
+    }
+}
+KeyboardService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: KeyboardService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+KeyboardService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: KeyboardService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: KeyboardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { clearKeys: [{
+                type: HostListener,
+                args: ["window:blur"]
+            }, {
+                type: HostListener,
+                args: ["window:resize"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyboard.service.js","sourceRoot":"","sources":["../../../../packages/common/src/services/keyboard.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, HostListener } from '@angular/core';\nimport { Subject } from 'rxjs';\n\nexport type KeyCommand = {\n    /**\n     * The non-modifier key(s) that must be pressed for the event to fire.\n     */\n    key: string | string[],\n    label: string,\n\n    ctrl?: boolean,\n    alt?: boolean,\n    shift?: boolean,\n    super?: boolean,\n    tab?: boolean,\n\n    /**\n     * Should the handler interrupt default event handling\n     */\n    interrupt?: boolean,\n}\n\n/**\n * Service that listens for global keyboard events\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class KeyboardService {\n\n    private heldKeys: { [key: string]: boolean } = {};\n    public keyCommands: {\n        ctrl?: boolean,\n        alt?: boolean,\n        shift?: boolean,\n        super?: boolean,\n        interrupt?: boolean,\n        label: string,\n        keys: string[],\n        sub: Subject<KeyboardEvent>\n    }[] = [];\n\n    constructor() {\n        window.addEventListener(\"keydown\", (evt) => this.onKeyDown(evt));\n        window.addEventListener(\"keyup\", (evt) => this.onKeyUp(evt));\n    }\n\n    private onKeyDown(evt: KeyboardEvent) {\n        // console.log(\"keydown\", evt.key)\n        this.heldKeys[evt.key.toLowerCase()] = true;\n\n        // Do a general filter where all of the modifiers must be matched if specified\n        // Then check that the actual keys match what was specified\n        let commands = this.keyCommands\n            .filter(kc =>\n                (kc.ctrl == undefined || kc.ctrl === evt.ctrlKey) &&\n                (kc.alt == undefined || kc.alt === evt.altKey) &&\n                (kc.shift == undefined || kc.shift === evt.shiftKey) &&\n                (kc.super == undefined || kc.super === evt.metaKey) &&\n                kc.keys.length == kc.keys.filter(k => this.heldKeys[k])?.length\n            );\n\n        if (evt.ctrlKey && commands.length > 0 || commands.find(c => c.interrupt)) {\n            evt.stopPropagation();\n            evt.preventDefault();\n        }\n\n        if (evt.key == \"Pause\")\n            debugger;\n\n        commands.forEach(kc => kc.sub.next(evt));\n\n        /**\n         * Prevent CTRL+P and other standard key events from being handled by the browser.\n         * Allow specific combonations:\n         * CTRL+W\n         * CTRL+T\n         * CTRL+F5\n         */\n        // if (evt.ctrlKey && !['w', 't', 'F5'].includes(evt.key)) {\n        //     evt.preventDefault();\n        // }\n    }\n\n    private onKeyUp(evt: KeyboardEvent) {\n        this.heldKeys[evt.key.toLowerCase()] = false;\n    }\n\n    private onKeyPress(evt: KeyboardEvent) {\n        // this.heldKeys[evt.key] = false;\n    }\n\n    /**\n     * Use this to subscribe to keyboard events throughout\n     * the application. This is a passive listener and will\n     * **NOT** interrupt the event chain.\n     */\n    public onKeyCommand(key: KeyCommand) {\n        const sub = new Subject<KeyboardEvent>();\n        let item = {\n            ...key,\n            keys: (Array.isArray(key.key) ? key.key : [key.key]),\n            sub: sub\n        }\n\n        this.keyCommands.push(item);\n\n        return {\n            ...sub,\n            subscribe: ((...args) => {\n                const s = sub.subscribe(...args);\n                return {\n                    ...s,\n                    unsubscribe: () => {\n                        s.unsubscribe();\n\n                        // Remove the keycommand from the list of listeners.\n                        const i = this.keyCommands.findIndex(c => c == item);\n                        this.keyCommands.splice(i, 1);\n                    }\n                };\n            }) as Subject<KeyboardEvent>['subscribe']\n        };\n    }\n\n    /**\n     * Return `true` if shift is currently pressed.\n     */\n    get isShiftPressed() {\n        return !!this.heldKeys[\"shift\"];\n    }\n    /**\n     * Return `true` if ctrl is currently pressed.\n     */\n    get isCtrlPressed() {\n        return !!this.heldKeys[\"control\"];\n    }\n    /**\n     * Return `true` if alt is currently pressed.\n     */\n    get isAltPressed() {\n        return !!this.heldKeys[\"alt\"];\n    }\n    /**\n     * Return `true` if super (mac/linux) or the windows key is currently pressed.\n     */\n    get isSuperPressed() {\n        return !!this.heldKeys[\"super\"];\n    }\n    /**\n     * Return `true` if tab is currently pressed.\n     */\n    get isTabPressed() {\n        return !!this.heldKeys[\"tab\"];\n    }\n\n    @HostListener(\"window:blur\")\n    @HostListener(\"window:resize\")\n    clearKeys() {\n        Object.keys(this.heldKeys).forEach(k => {\n            this.heldKeys[k] = false;\n        });\n    }\n}\n"]}

package/esm2020/types/menu.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/types/popup.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wdXAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vc3JjL3R5cGVzL3BvcHVwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBQb3B1cE9wdGlvbnMgPSBQYXJ0aWFsPHtcbiAgICAvKipcbiAgICAgKiBQb3NpdGlvbiByZWxhdGl2ZSB0byB0aGUgZWxlbWVudCB0aGUgbWVudSBwb3BzLXVwIGF0XG4gICAgICovXG4gICAgcG9zaXRpb246IFwidG9wXCIgfCBcInJpZ2h0XCIgfCBcImJvdHRvbVwiIHwgXCJsZWZ0XCIsXG4gICAgLyoqXG4gICAgICogSG93IHRoZSBwb3B1cCBpcyBhbGlnbmVkIHJlbGF0aXZlIHRvIHRoZSBlbGVtZW50XG4gICAgICovXG4gICAgYWxpZ25tZW50OiBcImNlbnRlclwiIHwgXCJiZWZvcmVzdGFydFwiIHwgXCJzdGFydFwiIHwgXCJlbmRcIiB8IFwiYWZ0ZXJlbmRcIixcbiAgICAvKipcbiAgICAgKiBAaGlkZGVuXG4gICAgICogV0lQOlxuICAgICAqIFNob3cgYW4gZXJyb3IgZnJvbSB0aGUgZGlhbG9nIHBvaW50aW5nIHRvIHRoZSBlbGVtZW50XG4gICAgICovXG4gICAgc2hvd0Fycm93OiBib29sZWFuLFxuICAgIC8qKlxuICAgICAqIEBoaWRkZW5cbiAgICAgKiBXSVA6XG4gICAgICogU2l6ZSBvZiB0aGUgYXJyb3cuXG4gICAgICovXG4gICAgYXJyb3dTaXplOiBudW1iZXIsXG4gICAgLyoqXG4gICAgICogSG93IG11Y2ggcGFkZGluZyB0byBhZGQgbmVhciB0aGUgZWRnZXMgb2YgdGhlIHNjcmVlbi5cbiAgICAgKi9cbiAgICBlZGdlUGFkZGluZzogbnVtYmVyLFxuXG4gICAgY3VzdG9tQ2xhc3M6IHN0cmluZ1tdO1xufT47XG4iXX0=

package/esm2020/utils/index.mjs

@@ -0,0 +1,39 @@
+export const sleep = ms => new Promise(r => setTimeout(r, ms));
+/**
+ * Prompt the user to save a json file of the given object.
+ */
+export const saveObjectAsFile = (name, data) => {
+    const a = document.createElement("a");
+    const file = new Blob([JSON.stringify(data)], { type: "application/json" });
+    a.href = URL.createObjectURL(file);
+    a.download = name;
+    a.click();
+    a.remove();
+};
+/**
+ * Formatted logger that will print a bit of context before the message.
+ * @returns
+ */
+export const Logger = (context, contextColor, textColor = "#03a9f4") => ({
+    log: (message, ...args) => {
+        console.log(`%c[${context}] %c${message}`, 'color: ' + contextColor, 'color: ' + textColor, ...args);
+    },
+    warn: (message, ...args) => {
+        console.warn(`%c[${context}] %c${message}`, 'color: ' + contextColor, 'color: ' + textColor, ...args);
+    },
+    err: (message, ...args) => {
+        console.error(`%c[${context}] %c${message}`, 'color: ' + contextColor, 'color: ' + textColor, ...args);
+    },
+    error: (message, ...args) => {
+        console.error(`%c[${context}] %c${message}`, 'color: ' + contextColor, 'color: ' + textColor, ...args);
+    }
+});
+/**
+ * Convert a string `fooBAR baz_160054''"1]"` into a slug: `foobar-baz-1600541`
+ */
+export const stringToSlug = (text) => (text || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[\-_+ ]/g, '-')
+    .replace(/[^a-z0-9\-]/g, '');
+//# sourceMappingURL=data:application/json;base64,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