@dotglitch/ngx-common 2.0.0 → 3.0.0-beta.2

package/esm2022/core/services/file.service.mjs

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./fetch.service";
+/**
+ * Service that listens for global keyboard events
+ */
+export class FileService {
+    constructor(fetch) {
+        this.fetch = fetch;
+        this.chooseFile = (accept, multiple = false, formMetadata = {}) => {
+            return new Promise(r => {
+                const inEl = document.createElement('input');
+                inEl.setAttribute('type', 'file');
+                if (multiple)
+                    inEl.setAttribute('multiple', '');
+                if (accept)
+                    inEl.setAttribute('accept', accept);
+                inEl.click();
+                let formData = new FormData();
+                inEl.addEventListener('change', () => {
+                    Object.keys(inEl.files).forEach(k => {
+                        const file = inEl.files[k];
+                        const name = file.name;
+                        formData.append(name, file);
+                    });
+                    formData.append("data", JSON.stringify(formMetadata));
+                    inEl.remove();
+                    r(formData);
+                });
+            });
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FileService, deps: [{ token: i1.Fetch }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FileService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FileService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Fetch }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/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;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: KeyboardService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: KeyboardService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: KeyboardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [], 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/core/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/esm2022/core/services/navigation.service.mjs

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../components/lazy-loader/lazy-loader.service";
+export class NavigationService {
+    constructor(lazyLoader) {
+        this.lazyLoader = lazyLoader;
+        this.virtualPath$ = new BehaviorSubject(null);
+        // @ts-ignore
+        window.onhashchange = () => this.loadRootPageFromUrl();
+        this.loadRootPageFromUrl();
+    }
+    loadRootPageFromUrl() {
+        const hash = location.hash.split("?")[0];
+        const root = hash.replace(/^\/?#\//, '');
+        // If the URL is imprecisely set, we restore it to the landing page
+        if (!root || !root.trim())
+            return this.loadRootPage("#/Landing");
+        this.loadRootPage(location.hash);
+    }
+    loadRootPage(url, data = {}) {
+        const [path, query] = url.split('?');
+        const hash = path.replace(/^\/?#\/?/, '');
+        const chunks = hash.split('/');
+        // Get query params and pass them as @Input arguments.
+        const params = query?.split('&')
+            .reduce((pars, par) => {
+            const [key, value] = par.split("=");
+            const decoded = decodeURIComponent(value);
+            pars[key] = decoded;
+            return pars;
+        }, {}) || {};
+        console.info(`Root page navigate to '${hash}'`, { params, chunks });
+        const root = hash.replace(/^\/?#\//, '');
+        this.virtualPath$.next({
+            root: hash,
+            chunks: chunks,
+            args: params
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, deps: [{ token: i1.LazyLoaderService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.LazyLoaderService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2aWdhdGlvbi5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tbW9uL2NvcmUvc2VydmljZXMvbmF2aWdhdGlvbi5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLE1BQU0sQ0FBQzs7O0FBY3ZDLE1BQU0sT0FBTyxpQkFBaUI7SUFHMUIsWUFDcUIsVUFBNkI7UUFBN0IsZUFBVSxHQUFWLFVBQVUsQ0FBbUI7UUFIM0MsaUJBQVksR0FBRyxJQUFJLGVBQWUsQ0FBc0IsSUFBSSxDQUFDLENBQUM7UUFLakUsYUFBYTtRQUNiLE1BQU0sQ0FBQyxZQUFZLEdBQUcsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLG1CQUFtQixFQUFFLENBQUM7UUFDdkQsSUFBSSxDQUFDLG1CQUFtQixFQUFFLENBQUM7SUFDL0IsQ0FBQztJQUVPLG1CQUFtQjtRQUN2QixNQUFNLElBQUksR0FBRyxRQUFRLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUN6QyxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsRUFBRSxFQUFFLENBQUMsQ0FBQztRQUV6QyxtRUFBbUU7UUFDbkUsSUFBSSxDQUFDLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUU7WUFDckIsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBRTFDLElBQUksQ0FBQyxZQUFZLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3JDLENBQUM7SUFFTyxZQUFZLENBQUMsR0FBVyxFQUFFLE9BQWUsRUFBRTtRQUUvQyxNQUFNLENBQUMsSUFBSSxFQUFFLEtBQUssQ0FBQyxHQUFHLEdBQUcsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDckMsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDMUMsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUUvQixzREFBc0Q7UUFDdEQsTUFBTSxNQUFNLEdBQUcsS0FBSyxFQUFFLEtBQUssQ0FBQyxHQUFHLENBQUM7YUFDM0IsTUFBTSxDQUFDLENBQUMsSUFBSSxFQUFFLEdBQUcsRUFBRSxFQUFFO1lBQ2xCLE1BQU0sQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUNwQyxNQUFNLE9BQU8sR0FBRyxrQkFBa0IsQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUMxQyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsT0FBTyxDQUFDO1lBQ3BCLE9BQU8sSUFBSSxDQUFDO1FBQ2hCLENBQUMsRUFBRSxFQUFFLENBQUMsSUFBSSxFQUFFLENBQUM7UUFHakIsT0FBTyxDQUFDLElBQUksQ0FBQywwQkFBMEIsSUFBSSxHQUFHLEVBQUUsRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLENBQUMsQ0FBQztRQUNwRSxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsRUFBRSxFQUFFLENBQUMsQ0FBQztRQUN6QyxJQUFJLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQztZQUNuQixJQUFJLEVBQUUsSUFBSTtZQUNWLE1BQU0sRUFBRSxNQUFhO1lBQ3JCLElBQUksRUFBRSxNQUFNO1NBQ2YsQ0FBQyxDQUFDO0lBQ1AsQ0FBQzsrR0E3Q1EsaUJBQWlCO21IQUFqQixpQkFBaUIsY0FGZCxNQUFNOzs0RkFFVCxpQkFBaUI7a0JBSDdCLFVBQVU7bUJBQUM7b0JBQ1IsVUFBVSxFQUFFLE1BQU07aUJBQ3JCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQmVoYXZpb3JTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBMYXp5TG9hZGVyU2VydmljZSB9IGZyb20gJy4uL2NvbXBvbmVudHMvbGF6eS1sb2FkZXIvbGF6eS1sb2FkZXIuc2VydmljZSc7XG5cbnR5cGUgTmF2aWdhdGlvbkFyZ3VtZW50cyA9IHtcbiAgICByb290OiBzdHJpbmcsXG4gICAgY2h1bmtzOiBbc3RyaW5nLCAuLi5zdHJpbmdbXV0sXG4gICAgYXJnczoge1xuICAgICAgICBba2V5OiBzdHJpbmddOiBhbnk7XG4gICAgfTtcbn07XG5cbkBJbmplY3RhYmxlKHtcbiAgICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgTmF2aWdhdGlvblNlcnZpY2Uge1xuICAgIHB1YmxpYyB2aXJ0dWFsUGF0aCQgPSBuZXcgQmVoYXZpb3JTdWJqZWN0PE5hdmlnYXRpb25Bcmd1bWVudHM+KG51bGwpO1xuXG4gICAgY29uc3RydWN0b3IoXG4gICAgICAgIHByaXZhdGUgcmVhZG9ubHkgbGF6eUxvYWRlcjogTGF6eUxvYWRlclNlcnZpY2VcbiAgICApIHtcbiAgICAgICAgLy8gQHRzLWlnbm9yZVxuICAgICAgICB3aW5kb3cub25oYXNoY2hhbmdlID0gKCkgPT4gdGhpcy5sb2FkUm9vdFBhZ2VGcm9tVXJsKCk7XG4gICAgICAgIHRoaXMubG9hZFJvb3RQYWdlRnJvbVVybCgpO1xuICAgIH1cblxuICAgIHByaXZhdGUgbG9hZFJvb3RQYWdlRnJvbVVybCgpIHtcbiAgICAgICAgY29uc3QgaGFzaCA9IGxvY2F0aW9uLmhhc2guc3BsaXQoXCI/XCIpWzBdO1xuICAgICAgICBjb25zdCByb290ID0gaGFzaC5yZXBsYWNlKC9eXFwvPyNcXC8vLCAnJyk7XG5cbiAgICAgICAgLy8gSWYgdGhlIFVSTCBpcyBpbXByZWNpc2VseSBzZXQsIHdlIHJlc3RvcmUgaXQgdG8gdGhlIGxhbmRpbmcgcGFnZVxuICAgICAgICBpZiAoIXJvb3QgfHwgIXJvb3QudHJpbSgpKVxuICAgICAgICAgICAgcmV0dXJuIHRoaXMubG9hZFJvb3RQYWdlKFwiIy9MYW5kaW5nXCIpO1xuXG4gICAgICAgIHRoaXMubG9hZFJvb3RQYWdlKGxvY2F0aW9uLmhhc2gpO1xuICAgIH1cblxuICAgIHByaXZhdGUgbG9hZFJvb3RQYWdlKHVybDogc3RyaW5nLCBkYXRhOiBPYmplY3QgPSB7fSkge1xuXG4gICAgICAgIGNvbnN0IFtwYXRoLCBxdWVyeV0gPSB1cmwuc3BsaXQoJz8nKTtcbiAgICAgICAgY29uc3QgaGFzaCA9IHBhdGgucmVwbGFjZSgvXlxcLz8jXFwvPy8sICcnKTtcbiAgICAgICAgY29uc3QgY2h1bmtzID0gaGFzaC5zcGxpdCgnLycpO1xuXG4gICAgICAgIC8vIEdldCBxdWVyeSBwYXJhbXMgYW5kIHBhc3MgdGhlbSBhcyBASW5wdXQgYXJndW1lbnRzLlxuICAgICAgICBjb25zdCBwYXJhbXMgPSBxdWVyeT8uc3BsaXQoJyYnKVxuICAgICAgICAgICAgLnJlZHVjZSgocGFycywgcGFyKSA9PiB7XG4gICAgICAgICAgICAgICAgY29uc3QgW2tleSwgdmFsdWVdID0gcGFyLnNwbGl0KFwiPVwiKTtcbiAgICAgICAgICAgICAgICBjb25zdCBkZWNvZGVkID0gZGVjb2RlVVJJQ29tcG9uZW50KHZhbHVlKTtcbiAgICAgICAgICAgICAgICBwYXJzW2tleV0gPSBkZWNvZGVkO1xuICAgICAgICAgICAgICAgIHJldHVybiBwYXJzO1xuICAgICAgICAgICAgfSwge30pIHx8IHt9O1xuXG5cbiAgICAgICAgY29uc29sZS5pbmZvKGBSb290IHBhZ2UgbmF2aWdhdGUgdG8gJyR7aGFzaH0nYCwgeyBwYXJhbXMsIGNodW5rcyB9KTtcbiAgICAgICAgY29uc3Qgcm9vdCA9IGhhc2gucmVwbGFjZSgvXlxcLz8jXFwvLywgJycpO1xuICAgICAgICB0aGlzLnZpcnR1YWxQYXRoJC5uZXh0KHtcbiAgICAgICAgICAgIHJvb3Q6IGhhc2gsXG4gICAgICAgICAgICBjaHVua3M6IGNodW5rcyBhcyBhbnksXG4gICAgICAgICAgICBhcmdzOiBwYXJhbXNcbiAgICAgICAgfSk7XG4gICAgfVxufVxuIl19

package/esm2022/core/services/theme.service.mjs

@@ -0,0 +1,64 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+const verifyTheme = (theme) => {
+    if (theme == 'dark' || theme == 'light')
+        return theme;
+    return 'auto';
+};
+const initialTheme = verifyTheme(localStorage['fiq.theme']);
+const initialDiscreteTheme = initialTheme != 'auto'
+    ? initialTheme
+    : window.matchMedia('(prefers-color-scheme: dark)').matches
+        ? 'dark'
+        : 'light';
+const getAutoTheme = () => {
+    return window.matchMedia('(prefers-color-scheme: dark)').matches
+        ? 'dark'
+        : 'light';
+};
+export class ThemeService {
+    constructor() {
+        this.themes = [
+            { label: "Dark", id: 'dark' },
+            { label: "Light", id: 'light' },
+            { label: "Automatic", id: 'auto' },
+        ];
+        this.selectedTheme = initialTheme;
+        /**
+         * This theme will always only be 'dark' or 'light'.
+         * For use with canvases and similar libraries.
+         */
+        this.theme = new BehaviorSubject(initialDiscreteTheme);
+        this.theme.subscribe(t => {
+            document.body.parentElement.classList.remove("theme-dark");
+            document.body.parentElement.classList.remove("theme-light");
+            document.body.parentElement.classList.add("theme-" + t);
+        });
+        // The system theme changed (either due to timed color themes or the user changing the mode)
+        window.matchMedia('(prefers-color-scheme: dark)').addEventListener("change", ev => {
+            if (localStorage['fiq.theme'] == "auto")
+                this.theme.next(getAutoTheme());
+        });
+    }
+    setTheme(t) {
+        const theme = verifyTheme(t);
+        localStorage['fiq.theme'] = theme;
+        this.selectedTheme = theme;
+        if (theme == 'auto') {
+            this.theme.next(getAutoTheme());
+        }
+        else {
+            this.theme.next(theme);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThemeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/types/popup.mjs

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

package/esm2022/core/utils/index.mjs

@@ -0,0 +1,69 @@
+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();
+};
+/**
+ * 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, '');
+/**
+* Helper to update the page URL.
+* @param page component page ID to load.
+* @param data string or JSON data for query params.
+*/
+export const updateUrl = (page, data = {}, replaceState = false) => {
+    const [oldHash, qstring] = location.hash.split('?');
+    if (!page)
+        page = oldHash.split('/')[1];
+    const hash = `#/${page}`;
+    // Convert the data object to JSON.
+    if (data instanceof URLSearchParams) {
+        data = [...data.entries()].map(([k, v]) => ({ [k]: v })).reduce((a, b) => ({ ...a, ...b }), {});
+    }
+    const query = new URLSearchParams(data);
+    const prevParams = new URLSearchParams(qstring);
+    // If the hash is the same, retain params.
+    if (hash == oldHash) {
+        replaceState = true;
+        for (const [key, value] of prevParams.entries())
+            if (!query.has(key))
+                query.set(key, prevParams.get(key));
+    }
+    for (const [key, val] of query.entries()) {
+        if (val == null ||
+            val == undefined ||
+            val == '' ||
+            val == 'null' ||
+            Number.isNaN(val) ||
+            val == 'NaN')
+            query.delete(key);
+    }
+    if (!(hash.toLowerCase() == "#/frame") || data['id'] == -1)
+        query.delete('id');
+    const strQuery = query.toString();
+    console.log(data, hash, strQuery);
+    if (replaceState) {
+        window.history.replaceState(data, '', hash + (strQuery ? ('?' + strQuery) : ''));
+    }
+    else {
+        window.history.pushState(data, '', hash + (strQuery ? ('?' + strQuery) : ''));
+    }
+};
+export const getUrlData = (source = window.location.hash) => {
+    const [hash, query] = source.split('?');
+    let data = new URLSearchParams(query);
+    return [...data.entries()].map(([k, v]) => ({ [k]: v })).reduce((a, b) => ({ ...a, ...b }), {});
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../packages/common/core/utils/index.ts"],"names":[],"mappings":"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","sourcesContent":["export const sleep = ms => new Promise(r => setTimeout(r, ms));\n\n/**\n * Prompt the user to save a json file of the given object.\n */\nexport const saveObjectAsFile = (name: string, data: Object) => {\n    const a = document.createElement(\"a\");\n    const file = new Blob([JSON.stringify(data)], { type: \"application/json\" });\n    a.href = URL.createObjectURL(file);\n    a.download = name;\n    a.click();\n    a.remove();\n};\n\n/**\n * Convert a string `fooBAR baz_160054''\"1]\"` into a slug: `foobar-baz-1600541`\n */\nexport const stringToSlug = (text: string) =>\n    (text || '')\n        .trim()\n        .toLowerCase()\n        .replace(/[\\-_+ ]/g, '-')\n        .replace(/[^a-z0-9\\-\\/]/g, '');\n\n\n/**\n* Helper to update the page URL.\n* @param page component page ID to load.\n* @param data string or JSON data for query params.\n*/\nexport const updateUrl = (page?: string, data: string | string[][] | Record<string, string | number> | URLSearchParams = {}, replaceState = false) => {\n    const [oldHash, qstring] = location.hash.split('?');\n\n    if (!page)\n        page = oldHash.split('/')[1];\n\n    const hash = `#/${page}`;\n\n    // Convert the data object to JSON.\n    if (data instanceof URLSearchParams) {\n        data = [...(data as any).entries()].map(([k, v]) => ({ [k]: v })).reduce((a, b) => ({ ...a, ...b }), {});\n    }\n\n    const query = new URLSearchParams(data as any) as any;\n    const prevParams = new URLSearchParams(qstring) as any;\n\n    // If the hash is the same, retain params.\n    if (hash == oldHash) {\n        replaceState = true;\n        for (const [key, value] of prevParams.entries())\n            if (!query.has(key))\n                query.set(key, prevParams.get(key));\n    }\n\n    for (const [key, val] of query.entries()) {\n        if (\n            val == null ||\n            val == undefined ||\n            val == '' ||\n            val == 'null' ||\n            Number.isNaN(val) ||\n            val == 'NaN'\n        )\n            query.delete(key);\n    }\n\n    if (!(hash.toLowerCase() == \"#/frame\") || data['id'] == -1)\n        query.delete('id');\n\n\n    const strQuery = query.toString();\n    console.log(data, hash, strQuery);\n    if (replaceState) {\n        window.history.replaceState(data, '', hash + (strQuery ? ('?' + strQuery) : ''));\n    }\n    else {\n        window.history.pushState(data, '', hash + (strQuery ? ('?' + strQuery) : ''));\n    }\n};\n\nexport const getUrlData = (source = window.location.hash) => {\n    const [hash, query] = source.split('?');\n    let data = new URLSearchParams(query) as any;\n    return [...data.entries()].map(([k, v]) => ({ [k]: v })).reduce((a, b) => ({ ...a, ...b }), {});\n};\n"]}

package/esm2022/dotglitch-ngx-common.mjs

@@ -1,5 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
-export * from './public-api';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG90Z2xpdGNoLW5neC1jb21tb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vc3JjL2RvdGdsaXRjaC1uZ3gtY29tbW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG90Z2xpdGNoLW5neC1jb21tb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9wYWNrYWdlcy9jb21tb24vZG90Z2xpdGNoLW5neC1jb21tb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/filemanager/dotglitch-ngx-common-filemanager.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG90Z2xpdGNoLW5neC1jb21tb24tZmlsZW1hbmFnZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vZmlsZW1hbmFnZXIvZG90Z2xpdGNoLW5neC1jb21tb24tZmlsZW1hbmFnZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=