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

package/esm2022/core/directives/utils.mjs

@@ -0,0 +1,120 @@
+/**
+ * This utils file exists outside of the strict angular DI zone
+ * This enables opening popups without requiring absolute DI bindings.
+ */
+export const getPosition = (el, config = {}, bounds) => {
+    // Bounds of the popup owner
+    const src = !!el['nodeName']
+        ? el.getBoundingClientRect()
+        : {
+            // It's a pointer event, so we'll take the X and Y from the pointer.
+            x: el['clientX'],
+            y: el['clientY'],
+            // Set a default tiny size, so we don't divide by zero.
+            width: 0.0001,
+            height: 0.0001
+        };
+    // Popup bounds
+    const { width, height } = bounds;
+    const winh = window.innerHeight;
+    const winw = window.innerWidth;
+    const cords = {
+        top: null,
+        left: null
+    };
+    if (config?.position == "left" || config?.position == "right" || !config?.position) {
+        switch (config?.alignment) {
+            case "end": {
+                // vertically bind to bottom
+                cords.top = src.y + src.height - height;
+                break;
+            }
+            case "afterend": {
+                // vertically bind below bottom
+                cords.top = src.y + src.height;
+                break;
+            }
+            case "beforestart": {
+                // vertically bind above top
+                cords.top = src.y - height;
+                break;
+            }
+            case "start": {
+                // vertically bind to top
+                cords.top = src.y;
+                break;
+            }
+            case "center":
+            default: {
+                // vertically center
+                cords.top = (src.y + (src.height / 2)) - (height / 2);
+                break;
+            }
+        }
+        // Apply bounds to prevent the dialog from being cut-off screen
+        // Lower bound
+        cords.top = Math.max(config?.edgePadding || 0, cords.top);
+        // Upper bound
+        cords.top = Math.min(winh - height, cords.top);
+        if (config?.position == "left") {
+            cords.left = src.x - (width + (config?.arrowSize || 0) + (config?.arrowPadding || 0));
+        }
+        if (config?.position == "right" || !config?.position) {
+            cords.left = src.x + (src.width + (config?.arrowSize || 0) + (config?.arrowPadding || 0));
+        }
+        // Lower bound
+        cords.left = Math.max(config?.edgePadding || 0, cords.left);
+        // Upper bound
+        cords.left = Math.min(winw - width, cords.left);
+    }
+    else if (config?.position == "top" || config?.position == "bottom") {
+        switch (config?.alignment) {
+            case "end": {
+                // vertically bind to right
+                cords.left = src.x + src.width - width;
+                break;
+            }
+            case "afterend": {
+                // vertically bind past right
+                cords.left = src.x + src.width;
+                break;
+            }
+            case "beforestart": {
+                // vertically bind before left
+                cords.left = src.x - width;
+                break;
+            }
+            case "start": {
+                // vertically bind to left
+                cords.left = src.x;
+                break;
+            }
+            case "center":
+            default: {
+                // vertically center
+                cords.left = (src.x + (src.width / 2)) - (width / 2);
+                break;
+            }
+        }
+        // Apply bounds to prevent the dialog from being cut-off screen
+        // Lower bound
+        cords.left = Math.max(config?.edgePadding || 0, cords.left);
+        // Upper bound
+        cords.left = Math.min(winw - width, cords.left);
+        if (config?.position == "top") {
+            cords.top = src.y - (height + (config?.arrowSize || 0) + (config?.arrowPadding || 0));
+        }
+        if (config?.position == "bottom") {
+            cords.top = src.y + (src.height + (config?.arrowSize || 0) + (config?.arrowPadding || 0));
+        }
+        // Lower bound
+        cords.top = Math.max(config?.edgePadding || 0, cords.top);
+        // Upper bound
+        cords.top = Math.min(winh - height, cords.top);
+    }
+    // Assign unit
+    cords.top = cords.top + 'px';
+    cords.left = cords.left + 'px';
+    return cords;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../packages/common/core/directives/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This utils file exists outside of the strict angular DI zone\n * This enables opening popups without requiring absolute DI bindings.\n */\n\nexport const getPosition = (el: HTMLElement | PointerEvent, config: any = {}, bounds: DOMRect) => {\n    // Bounds of the popup owner\n    const src: DOMRect = !!el['nodeName']\n                ? (el as HTMLElement).getBoundingClientRect()\n                : {\n                    // It's a pointer event, so we'll take the X and Y from the pointer.\n                    x: el['clientX'],\n                    y: el['clientY'],\n                    // Set a default tiny size, so we don't divide by zero.\n                    width: 0.0001,\n                    height: 0.0001\n                } as DOMRect;\n\n    // Popup bounds\n    const { width, height } = bounds;\n\n    const winh = window.innerHeight;\n    const winw = window.innerWidth;\n\n    const cords = {\n        top: null,\n        left: null\n    };\n\n    if (config?.position == \"left\" || config?.position == \"right\" || !config?.position) {\n        switch (config?.alignment) {\n\n            case \"end\": {\n                // vertically bind to bottom\n                cords.top = src.y + src.height - height;\n                break;\n            }\n            case \"afterend\": {\n                // vertically bind below bottom\n                cords.top = src.y + src.height;\n                break;\n            }\n            case \"beforestart\": {\n                // vertically bind above top\n                cords.top = src.y - height;\n                break;\n            }\n            case \"start\": {\n                // vertically bind to top\n                cords.top = src.y;\n                break;\n            }\n            case \"center\":\n            default: {\n                // vertically center\n                cords.top = (src.y + (src.height / 2)) - (height / 2);\n                break;\n            }\n        }\n\n        // Apply bounds to prevent the dialog from being cut-off screen\n        // Lower bound\n        cords.top = Math.max(config?.edgePadding || 0, cords.top);\n        // Upper bound\n        cords.top = Math.min(winh - height, cords.top);\n\n        if (config?.position == \"left\") {\n            cords.left = src.x - (width + (config?.arrowSize || 0) + (config?.arrowPadding || 0));\n        }\n        if (config?.position == \"right\" || !config?.position) {\n            cords.left = src.x + (src.width + (config?.arrowSize || 0) + (config?.arrowPadding || 0));\n        }\n\n        // Lower bound\n        cords.left = Math.max(config?.edgePadding || 0, cords.left);\n        // Upper bound\n        cords.left = Math.min(winw - width, cords.left);\n    }\n    else if (config?.position == \"top\" || config?.position == \"bottom\") {\n        switch (config?.alignment) {\n            case \"end\": {\n                // vertically bind to right\n                cords.left = src.x + src.width - width;\n                break;\n            }\n            case \"afterend\": {\n                // vertically bind past right\n                cords.left = src.x + src.width;\n                break;\n            }\n            case \"beforestart\": {\n                // vertically bind before left\n                cords.left = src.x - width;\n                break;\n            }\n            case \"start\": {\n                // vertically bind to left\n                cords.left = src.x;\n                break;\n            }\n            case \"center\":\n            default: {\n                // vertically center\n                cords.left = (src.x + (src.width / 2)) - (width / 2);\n                break;\n            }\n        }\n\n        // Apply bounds to prevent the dialog from being cut-off screen\n        // Lower bound\n        cords.left = Math.max(config?.edgePadding || 0, cords.left);\n        // Upper bound\n        cords.left = Math.min(winw - width, cords.left);\n\n\n        if (config?.position == \"top\") {\n            cords.top = src.y - (height + (config?.arrowSize || 0) + (config?.arrowPadding || 0));\n        }\n        if (config?.position == \"bottom\") {\n            cords.top = src.y + (src.height + (config?.arrowSize || 0) + (config?.arrowPadding || 0));\n        }\n\n        // Lower bound\n        cords.top = Math.max(config?.edgePadding || 0, cords.top);\n        // Upper bound\n        cords.top = Math.min(winh - height, cords.top);\n    }\n\n    // Assign unit\n    cords.top = cords.top + 'px';\n    cords.left = cords.left + 'px';\n\n    return cords;\n}\n"]}

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

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

package/esm2022/core/index.mjs

@@ -0,0 +1,50 @@
+; /*
+ * Public API Surface of package
+ */
+/**
+ ** Types
+ */
+export * from './types/popup';
+/**
+ ** Directives
+ */
+export * from './directives/image-cache.directive';
+/**
+ ** Pipes
+ */
+export * from './pipes/html-bypass.pipe';
+export * from './pipes/resource-bypass.pipe';
+export * from './pipes/script-bypass.pipe';
+export * from './pipes/style-bypass.pipe';
+export * from './pipes/url-bypass.pipe';
+/**
+** Services
+*/
+export * from './services/dependency.service';
+export * from './services/dialog.service';
+export * from './services/fetch.service';
+export * from './services/file.service';
+export * from './services/keyboard.service';
+export * from './services/navigation.service';
+export * from './services/theme.service';
+/**
+** Lazy loader component & service
+*/
+export * from './components/lazy-loader/lazy-loader.component';
+export * from './components/lazy-loader/lazy-loader.module';
+export * from './components/lazy-loader/lazy-loader.service';
+export * from './components/lazy-loader/types';
+/**
+ ** Components
+ */
+export * from './components/parallax-card/parallax-card.component';
+export * from './components/types';
+/**
+ ** Menu
+ */
+export * from './components/menu/menu.component';
+export * from './components/menu/menu.directive';
+export * from './components/menu/types';
+export * from './directives/utils';
+export * from './utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vY29yZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxDQUFDLENBQUE7O0dBRUU7QUFFSDs7R0FFRztBQUNILGNBQWMsZUFBZSxDQUFDO0FBRTlCOztHQUVHO0FBQ0gsY0FBYyxvQ0FBb0MsQ0FBQztBQUVuRDs7R0FFRztBQUNILGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx5QkFBeUIsQ0FBQztBQUV4Qzs7RUFFRTtBQUNGLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsMEJBQTBCLENBQUM7QUFFekM7O0VBRUU7QUFDRixjQUFjLGdEQUFnRCxDQUFDO0FBQy9ELGNBQWMsNkNBQTZDLENBQUM7QUFDNUQsY0FBYyw4Q0FBOEMsQ0FBQztBQUM3RCxjQUFjLGdDQUFnQyxDQUFDO0FBRS9DOztHQUVHO0FBQ0gsY0FBYyxvREFBb0QsQ0FBQztBQUNuRSxjQUFjLG9CQUFvQixDQUFDO0FBRW5DOztHQUVHO0FBQ0gsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMseUJBQXlCLENBQUM7QUFFeEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIjsvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIHBhY2thZ2VcbiAqL1xuXG4vKipcbiAqKiBUeXBlc1xuICovXG5leHBvcnQgKiBmcm9tICcuL3R5cGVzL3BvcHVwJztcblxuLyoqXG4gKiogRGlyZWN0aXZlc1xuICovXG5leHBvcnQgKiBmcm9tICcuL2RpcmVjdGl2ZXMvaW1hZ2UtY2FjaGUuZGlyZWN0aXZlJztcblxuLyoqXG4gKiogUGlwZXNcbiAqL1xuZXhwb3J0ICogZnJvbSAnLi9waXBlcy9odG1sLWJ5cGFzcy5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vcGlwZXMvcmVzb3VyY2UtYnlwYXNzLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9waXBlcy9zY3JpcHQtYnlwYXNzLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9waXBlcy9zdHlsZS1ieXBhc3MucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3BpcGVzL3VybC1ieXBhc3MucGlwZSc7XG5cbi8qKlxuKiogU2VydmljZXNcbiovXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2RlcGVuZGVuY3kuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2RpYWxvZy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvZmV0Y2guc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2ZpbGUuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2tleWJvYXJkLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcy9uYXZpZ2F0aW9uLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcy90aGVtZS5zZXJ2aWNlJztcblxuLyoqXG4qKiBMYXp5IGxvYWRlciBjb21wb25lbnQgJiBzZXJ2aWNlXG4qL1xuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL2xhenktbG9hZGVyL2xhenktbG9hZGVyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvbGF6eS1sb2FkZXIvbGF6eS1sb2FkZXIubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9sYXp5LWxvYWRlci9sYXp5LWxvYWRlci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9sYXp5LWxvYWRlci90eXBlcyc7XG5cbi8qKlxuICoqIENvbXBvbmVudHNcbiAqL1xuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL3BhcmFsbGF4LWNhcmQvcGFyYWxsYXgtY2FyZC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL3R5cGVzJztcblxuLyoqXG4gKiogTWVudVxuICovXG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvbWVudS9tZW51LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvbWVudS9tZW51LmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvbWVudS90eXBlcyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aXZlcy91dGlscyc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxzJztcblxuIl19

package/esm2022/core/pipes/html-bypass.pipe.mjs

@@ -0,0 +1,27 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+/**
+ * Url Sanitizer pipe.
+ *
+ * This trusts URLs that exist in a safe list defined in our environments.ts file.
+ * Any other URLs will NOT be trusted, thus will not be loaded.
+ */
+export class HtmlBypass {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(url) {
+        return this.sanitizer.bypassSecurityTrustHtml(url);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HtmlBypass, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: HtmlBypass, isStandalone: true, name: "htmlbypass" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HtmlBypass, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'htmlbypass',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.DomSanitizer }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHRtbC1ieXBhc3MucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbW1vbi9jb3JlL3BpcGVzL2h0bWwtYnlwYXNzLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBa0MsTUFBTSxlQUFlLENBQUM7OztBQUdyRTs7Ozs7R0FLRztBQUtILE1BQU0sT0FBTyxVQUFVO0lBRW5CLFlBQW9CLFNBQXVCO1FBQXZCLGNBQVMsR0FBVCxTQUFTLENBQWM7SUFBSSxDQUFDO0lBRXpDLFNBQVMsQ0FBQyxHQUFXO1FBQ3hCLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyx1QkFBdUIsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUN2RCxDQUFDOytHQU5RLFVBQVU7NkdBQVYsVUFBVTs7NEZBQVYsVUFBVTtrQkFKdEIsSUFBSTttQkFBQztvQkFDRixJQUFJLEVBQUUsWUFBWTtvQkFDbEIsVUFBVSxFQUFFLElBQUk7aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSwgU2VjdXJpdHlDb250ZXh0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEb21TYW5pdGl6ZXIsIFNhZmVVcmwgfSBmcm9tICdAYW5ndWxhci9wbGF0Zm9ybS1icm93c2VyJztcblxuLyoqXG4gKiBVcmwgU2FuaXRpemVyIHBpcGUuXG4gKlxuICogVGhpcyB0cnVzdHMgVVJMcyB0aGF0IGV4aXN0IGluIGEgc2FmZSBsaXN0IGRlZmluZWQgaW4gb3VyIGVudmlyb25tZW50cy50cyBmaWxlLlxuICogQW55IG90aGVyIFVSTHMgd2lsbCBOT1QgYmUgdHJ1c3RlZCwgdGh1cyB3aWxsIG5vdCBiZSBsb2FkZWQuXG4gKi9cbkBQaXBlKHtcbiAgICBuYW1lOiAnaHRtbGJ5cGFzcycsXG4gICAgc3RhbmRhbG9uZTogdHJ1ZVxufSlcbmV4cG9ydCBjbGFzcyBIdG1sQnlwYXNzIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG5cbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIHNhbml0aXplcjogRG9tU2FuaXRpemVyKSB7IH1cblxuICAgIHB1YmxpYyB0cmFuc2Zvcm0odXJsOiBzdHJpbmcpOiBTYWZlVXJsIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuc2FuaXRpemVyLmJ5cGFzc1NlY3VyaXR5VHJ1c3RIdG1sKHVybCk7XG4gICAgfVxufVxuIl19

package/esm2022/core/pipes/resource-bypass.pipe.mjs

@@ -0,0 +1,27 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+/**
+ * Url Sanitizer pipe.
+ *
+ * This trusts URLs that exist in a safe list defined in our environments.ts file.
+ * Any other URLs will NOT be trusted, thus will not be loaded.
+ */
+export class ResourceBypass {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(url) {
+        return this.sanitizer.bypassSecurityTrustResourceUrl(url);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ResourceBypass, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: ResourceBypass, isStandalone: true, name: "resourcebypass" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ResourceBypass, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'resourcebypass',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.DomSanitizer }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb3VyY2UtYnlwYXNzLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vY29yZS9waXBlcy9yZXNvdXJjZS1ieXBhc3MucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFrQyxNQUFNLGVBQWUsQ0FBQzs7O0FBR3JFOzs7OztHQUtHO0FBS0gsTUFBTSxPQUFPLGNBQWM7SUFFdkIsWUFBb0IsU0FBdUI7UUFBdkIsY0FBUyxHQUFULFNBQVMsQ0FBYztJQUFJLENBQUM7SUFFekMsU0FBUyxDQUFDLEdBQVc7UUFDeEIsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLDhCQUE4QixDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQzlELENBQUM7K0dBTlEsY0FBYzs2R0FBZCxjQUFjOzs0RkFBZCxjQUFjO2tCQUoxQixJQUFJO21CQUFDO29CQUNGLElBQUksRUFBRSxnQkFBZ0I7b0JBQ3RCLFVBQVUsRUFBRSxJQUFJO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0sIFNlY3VyaXR5Q29udGV4dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRG9tU2FuaXRpemVyLCBTYWZlVXJsIH0gZnJvbSAnQGFuZ3VsYXIvcGxhdGZvcm0tYnJvd3Nlcic7XG5cbi8qKlxuICogVXJsIFNhbml0aXplciBwaXBlLlxuICpcbiAqIFRoaXMgdHJ1c3RzIFVSTHMgdGhhdCBleGlzdCBpbiBhIHNhZmUgbGlzdCBkZWZpbmVkIGluIG91ciBlbnZpcm9ubWVudHMudHMgZmlsZS5cbiAqIEFueSBvdGhlciBVUkxzIHdpbGwgTk9UIGJlIHRydXN0ZWQsIHRodXMgd2lsbCBub3QgYmUgbG9hZGVkLlxuICovXG5AUGlwZSh7XG4gICAgbmFtZTogJ3Jlc291cmNlYnlwYXNzJyxcbiAgICBzdGFuZGFsb25lOiB0cnVlXG59KVxuZXhwb3J0IGNsYXNzIFJlc291cmNlQnlwYXNzIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG5cbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIHNhbml0aXplcjogRG9tU2FuaXRpemVyKSB7IH1cblxuICAgIHB1YmxpYyB0cmFuc2Zvcm0odXJsOiBzdHJpbmcpOiBTYWZlVXJsIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuc2FuaXRpemVyLmJ5cGFzc1NlY3VyaXR5VHJ1c3RSZXNvdXJjZVVybCh1cmwpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2022/core/pipes/script-bypass.pipe.mjs

@@ -0,0 +1,27 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+/**
+ * Url Sanitizer pipe.
+ *
+ * This trusts URLs that exist in a safe list defined in our environments.ts file.
+ * Any other URLs will NOT be trusted, thus will not be loaded.
+ */
+export class ScriptBypass {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(url) {
+        return this.sanitizer.bypassSecurityTrustScript(url);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ScriptBypass, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: ScriptBypass, isStandalone: true, name: "scriptbypass" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ScriptBypass, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'scriptbypass',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.DomSanitizer }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NyaXB0LWJ5cGFzcy5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tbW9uL2NvcmUvcGlwZXMvc2NyaXB0LWJ5cGFzcy5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWtDLE1BQU0sZUFBZSxDQUFDOzs7QUFHckU7Ozs7O0dBS0c7QUFLSCxNQUFNLE9BQU8sWUFBWTtJQUVyQixZQUFvQixTQUF1QjtRQUF2QixjQUFTLEdBQVQsU0FBUyxDQUFjO0lBQUksQ0FBQztJQUV6QyxTQUFTLENBQUMsR0FBVztRQUN4QixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMseUJBQXlCLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDekQsQ0FBQzsrR0FOUSxZQUFZOzZHQUFaLFlBQVk7OzRGQUFaLFlBQVk7a0JBSnhCLElBQUk7bUJBQUM7b0JBQ0YsSUFBSSxFQUFFLGNBQWM7b0JBQ3BCLFVBQVUsRUFBRSxJQUFJO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0sIFNlY3VyaXR5Q29udGV4dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRG9tU2FuaXRpemVyLCBTYWZlVXJsIH0gZnJvbSAnQGFuZ3VsYXIvcGxhdGZvcm0tYnJvd3Nlcic7XG5cbi8qKlxuICogVXJsIFNhbml0aXplciBwaXBlLlxuICpcbiAqIFRoaXMgdHJ1c3RzIFVSTHMgdGhhdCBleGlzdCBpbiBhIHNhZmUgbGlzdCBkZWZpbmVkIGluIG91ciBlbnZpcm9ubWVudHMudHMgZmlsZS5cbiAqIEFueSBvdGhlciBVUkxzIHdpbGwgTk9UIGJlIHRydXN0ZWQsIHRodXMgd2lsbCBub3QgYmUgbG9hZGVkLlxuICovXG5AUGlwZSh7XG4gICAgbmFtZTogJ3NjcmlwdGJ5cGFzcycsXG4gICAgc3RhbmRhbG9uZTogdHJ1ZVxufSlcbmV4cG9ydCBjbGFzcyBTY3JpcHRCeXBhc3MgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcblxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgc2FuaXRpemVyOiBEb21TYW5pdGl6ZXIpIHsgfVxuXG4gICAgcHVibGljIHRyYW5zZm9ybSh1cmw6IHN0cmluZyk6IFNhZmVVcmwge1xuICAgICAgICByZXR1cm4gdGhpcy5zYW5pdGl6ZXIuYnlwYXNzU2VjdXJpdHlUcnVzdFNjcmlwdCh1cmwpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2022/core/pipes/style-bypass.pipe.mjs

@@ -0,0 +1,27 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+/**
+ * Url Sanitizer pipe.
+ *
+ * This trusts URLs that exist in a safe list defined in our environments.ts file.
+ * Any other URLs will NOT be trusted, thus will not be loaded.
+ */
+export class StyleBypass {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(url) {
+        return this.sanitizer.bypassSecurityTrustStyle(url);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StyleBypass, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: StyleBypass, isStandalone: true, name: "stylebypass" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StyleBypass, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'stylebypass',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.DomSanitizer }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3R5bGUtYnlwYXNzLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vY29yZS9waXBlcy9zdHlsZS1ieXBhc3MucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFrQyxNQUFNLGVBQWUsQ0FBQzs7O0FBR3JFOzs7OztHQUtHO0FBS0gsTUFBTSxPQUFPLFdBQVc7SUFFcEIsWUFBb0IsU0FBdUI7UUFBdkIsY0FBUyxHQUFULFNBQVMsQ0FBYztJQUFJLENBQUM7SUFFekMsU0FBUyxDQUFDLEdBQVc7UUFDeEIsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLHdCQUF3QixDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ3hELENBQUM7K0dBTlEsV0FBVzs2R0FBWCxXQUFXOzs0RkFBWCxXQUFXO2tCQUp2QixJQUFJO21CQUFDO29CQUNGLElBQUksRUFBRSxhQUFhO29CQUNuQixVQUFVLEVBQUUsSUFBSTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtLCBTZWN1cml0eUNvbnRleHQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IERvbVNhbml0aXplciwgU2FmZVVybCB9IGZyb20gJ0Bhbmd1bGFyL3BsYXRmb3JtLWJyb3dzZXInO1xuXG4vKipcbiAqIFVybCBTYW5pdGl6ZXIgcGlwZS5cbiAqXG4gKiBUaGlzIHRydXN0cyBVUkxzIHRoYXQgZXhpc3QgaW4gYSBzYWZlIGxpc3QgZGVmaW5lZCBpbiBvdXIgZW52aXJvbm1lbnRzLnRzIGZpbGUuXG4gKiBBbnkgb3RoZXIgVVJMcyB3aWxsIE5PVCBiZSB0cnVzdGVkLCB0aHVzIHdpbGwgbm90IGJlIGxvYWRlZC5cbiAqL1xuQFBpcGUoe1xuICAgIG5hbWU6ICdzdHlsZWJ5cGFzcycsXG4gICAgc3RhbmRhbG9uZTogdHJ1ZVxufSlcbmV4cG9ydCBjbGFzcyBTdHlsZUJ5cGFzcyBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSBzYW5pdGl6ZXI6IERvbVNhbml0aXplcikgeyB9XG5cbiAgICBwdWJsaWMgdHJhbnNmb3JtKHVybDogc3RyaW5nKTogU2FmZVVybCB7XG4gICAgICAgIHJldHVybiB0aGlzLnNhbml0aXplci5ieXBhc3NTZWN1cml0eVRydXN0U3R5bGUodXJsKTtcbiAgICB9XG59XG4iXX0=

package/esm2022/core/pipes/url-bypass.pipe.mjs

@@ -0,0 +1,27 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+/**
+ * Url Sanitizer pipe.
+ *
+ * This trusts URLs that exist in a safe list defined in our environments.ts file.
+ * Any other URLs will NOT be trusted, thus will not be loaded.
+ */
+export class UrlBypass {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(url) {
+        return this.sanitizer.bypassSecurityTrustUrl(url);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UrlBypass, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: UrlBypass, isStandalone: true, name: "urlbypass" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UrlBypass, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'urlbypass',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.DomSanitizer }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXJsLWJ5cGFzcy5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tbW9uL2NvcmUvcGlwZXMvdXJsLWJ5cGFzcy5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWtDLE1BQU0sZUFBZSxDQUFDOzs7QUFHckU7Ozs7O0dBS0c7QUFLSCxNQUFNLE9BQU8sU0FBUztJQUVsQixZQUFvQixTQUF1QjtRQUF2QixjQUFTLEdBQVQsU0FBUyxDQUFjO0lBQUksQ0FBQztJQUV6QyxTQUFTLENBQUMsR0FBVztRQUN4QixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsc0JBQXNCLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDdEQsQ0FBQzsrR0FOUSxTQUFTOzZHQUFULFNBQVM7OzRGQUFULFNBQVM7a0JBSnJCLElBQUk7bUJBQUM7b0JBQ0YsSUFBSSxFQUFFLFdBQVc7b0JBQ2pCLFVBQVUsRUFBRSxJQUFJO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0sIFNlY3VyaXR5Q29udGV4dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRG9tU2FuaXRpemVyLCBTYWZlVXJsIH0gZnJvbSAnQGFuZ3VsYXIvcGxhdGZvcm0tYnJvd3Nlcic7XG5cbi8qKlxuICogVXJsIFNhbml0aXplciBwaXBlLlxuICpcbiAqIFRoaXMgdHJ1c3RzIFVSTHMgdGhhdCBleGlzdCBpbiBhIHNhZmUgbGlzdCBkZWZpbmVkIGluIG91ciBlbnZpcm9ubWVudHMudHMgZmlsZS5cbiAqIEFueSBvdGhlciBVUkxzIHdpbGwgTk9UIGJlIHRydXN0ZWQsIHRodXMgd2lsbCBub3QgYmUgbG9hZGVkLlxuICovXG5AUGlwZSh7XG4gICAgbmFtZTogJ3VybGJ5cGFzcycsXG4gICAgc3RhbmRhbG9uZTogdHJ1ZVxufSlcbmV4cG9ydCBjbGFzcyBVcmxCeXBhc3MgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcblxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgc2FuaXRpemVyOiBEb21TYW5pdGl6ZXIpIHsgfVxuXG4gICAgcHVibGljIHRyYW5zZm9ybSh1cmw6IHN0cmluZyk6IFNhZmVVcmwge1xuICAgICAgICByZXR1cm4gdGhpcy5zYW5pdGl6ZXIuYnlwYXNzU2VjdXJpdHlUcnVzdFVybCh1cmwpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2022/core/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);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DependencyService, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DependencyService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DependencyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,67 @@
+import { Injectable } from '@angular/core';
+import { LazyLoaderComponent } from '../components/lazy-loader/lazy-loader.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "../components/lazy-loader/lazy-loader.service";
+export class DialogService {
+    constructor(dialog, lazyLoader) {
+        this.dialog = dialog;
+        this.lazyLoader = lazyLoader;
+        this.dialogs = [];
+    }
+    open(name, groupOrOptions, opts = {}) {
+        const group = typeof groupOrOptions == "string" ? groupOrOptions : 'default';
+        if (typeof groupOrOptions == 'object')
+            opts = groupOrOptions;
+        return new Promise((resolve, reject) => {
+            const registration = this.lazyLoader.resolveRegistrationEntry(name, group);
+            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: group
+                },
+                panelClass: [
+                    "dialog-" + name,
+                    ...(Array.isArray(opts.panelClass) ? opts.panelClass : [opts.panelClass])
+                ]
+            };
+            let dialog = this.dialog.open(LazyLoaderComponent, args);
+            dialog['idx'] = name;
+            this.dialogs.push(dialog);
+            dialog.afterClosed().subscribe(result => {
+                console.info("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());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogService, deps: [{ token: i1.MatDialog }, { token: i2.LazyLoaderService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.MatDialog }, { type: i2.LazyLoaderService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"","sources":["../../../../packages/common/core/services/dialog.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;;;;AAsBtF,MAAM,OAAO,aAAa;IAItB,YACY,MAAiB,EACjB,UAA6B;QAD7B,WAAM,GAAN,MAAM,CAAW;QACjB,eAAU,GAAV,UAAU,CAAmB;QAJjC,YAAO,GAAiC,EAAE,CAAC;IAMnD,CAAC;IAMD,IAAI,CAAC,IAAY,EAAE,cAAoB,EAAE,OAAsB,EAAE;QAC7D,MAAM,KAAK,GAAG,OAAO,cAAc,IAAI,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC;QAC7E,IAAI,OAAO,cAAc,IAAI,QAAQ;YACjC,IAAI,GAAG,cAAc,CAAC;QAE1B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAEnC,MAAM,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,wBAAwB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAC3E,IAAI,CAAC,YAAY;gBACb,OAAO,MAAM,CAAC,IAAI,KAAK,CAAC,yBAAyB,GAAG,IAAI,GAAG,+BAA+B,CAAC,CAAC,CAAC;YAGjG,MAAM,IAAI,GAAoB;gBAC1B,iBAAiB,EAAE,IAAI;gBACvB,YAAY,EAAE,IAAI;gBAClB,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC;gBAC5B,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC;gBAC9B,GAAG,IAAI;gBACP,IAAI,EAAE;oBACF,EAAE,EAAE,IAAI;oBACR,MAAM,EAAE,IAAI,CAAC,MAAM,IAAI,EAAE;oBACzB,OAAO,EAAE,IAAI,CAAC,OAAO,IAAI,EAAE;oBAC3B,KAAK,EAAE,KAAK;iBACf;gBACD,UAAU,EAAE;oBACR,SAAS,GAAG,IAAI;oBAChB,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;iBAC5E;aACJ,CAAC;YAEF,IAAI,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,EAAE,IAAI,CAAC,CAAC;YAEzD,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;YACrB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAE1B,MAAM,CAAC,WAAW,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;gBACpC,OAAO,CAAC,IAAI,CAAC,gBAAgB,GAAG,IAAI,EAAE,MAAM,CAAC,CAAC;gBAC9C,OAAO,CAAC,MAAM,CAAC,CAAC;YACpB,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACP,CAAC;IAED,4CAA4C;IAC5C,KAAK,CAAC,IAAY;QACd,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC;QAC3D,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;IAC9C,CAAC;IAED;;;OAGG;IACH,WAAW;QACP,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;IACnD,CAAC;+GApEQ,aAAa;mHAAb,aAAa,cAFV,MAAM;;4FAET,aAAa;kBAHzB,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { MatDialog, MatDialogConfig, MatDialogRef } from '@angular/material/dialog';\nimport { LazyLoaderComponent } from '../components/lazy-loader/lazy-loader.component';\nimport { LazyLoaderService } from '../components/lazy-loader/lazy-loader.service';\n\nexport type DialogOptions = Partial<Omit<MatDialogConfig<any>, 'data'> & {\n    /**\n     * List of properties to be provided to @Input() injectors\n     */\n    inputs: { [key: string]: any; },\n    /**\n     * List of properties to be provided to @Input() injectors\n     */\n    outputs: { [key: string]: Function; },\n    /**\n     * Context in which to execute callbacks from the `outputs` property via\n     * @Output() event Emitters\n     */\n    parent: any;\n}>;\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class DialogService {\n\n    private dialogs: MatDialogRef<unknown, any>[] = [];\n\n    constructor(\n        private dialog: MatDialog,\n        private lazyLoader: LazyLoaderService\n    ) {\n    }\n\n    open(name: string);\n    open(name: string, opts: DialogOptions);\n    open(name: string, group: string);\n    open(name: string, group: string, opts: DialogOptions);\n    open(name: string, groupOrOptions?: any, opts: DialogOptions = {}): Promise<any> {\n        const group = typeof groupOrOptions == \"string\" ? groupOrOptions : 'default';\n        if (typeof groupOrOptions == 'object')\n            opts = groupOrOptions;\n\n        return new Promise((resolve, reject) => {\n\n            const registration = this.lazyLoader.resolveRegistrationEntry(name, group);\n            if (!registration)\n                return reject(new Error(\"Cannot open dialog for \" + name + \". Could not find in registry.\"));\n\n\n            const args: MatDialogConfig = {\n                closeOnNavigation: true,\n                restoreFocus: true,\n                width: registration['width'],\n                height: registration['height'],\n                ...opts,\n                data: {\n                    id: name,\n                    inputs: opts.inputs || {},\n                    outputs: opts.outputs || {},\n                    group: group\n                },\n                panelClass: [\n                    \"dialog-\" + name,\n                    ...(Array.isArray(opts.panelClass) ? opts.panelClass : [opts.panelClass])\n                ]\n            };\n\n            let dialog = this.dialog.open(LazyLoaderComponent, args);\n\n            dialog['idx'] = name;\n            this.dialogs.push(dialog);\n\n            dialog.afterClosed().subscribe(result => {\n                console.info(\"Dialog closed \" + name, result);\n                resolve(result);\n            });\n        });\n    }\n\n    // Close all dialogs matching the given name\n    close(name: string) {\n        const dialogs = this.dialogs.filter(d => d['idx'] == name);\n        dialogs.forEach(dialog => dialog.close());\n    }\n\n    /**\n     * Method to close _all_ dialogs.\n     * Should be used sparingly.\n     */\n    clearDialog() {\n        this.dialogs.forEach(dialog => dialog.close());\n    }\n\n    /**\n     * Open a confirmation dialog. Will reject if a cancel occurs.\n     * @param title title of the dialog\n     * @param message main question that a user needs to confirm/deny\n     * @returns\n     */\n    // confirmAction(title: string, message: string): Promise<void> {\n    //     return new Promise((res, rej) => {\n    //         const dialog = this.dialog.open(ConfirmationComponent, {\n    //             maxHeight: \"90vh\",\n    //             maxWidth: \"90vw\",\n    //             panelClass: [\"dialog-confirmation\"],\n    //             closeOnNavigation: true,\n    //             restoreFocus: true,\n    //             data: {title, message}\n    //         });\n\n    //         dialog.afterClosed().subscribe(result => {\n    //             result == true ? res() : rej();\n    //         });\n    //     });\n    // }\n}\n"]}

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

@@ -0,0 +1,74 @@
+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;
+        let abort = false;
+        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");
+                    abort = true;
+                    reject(error);
+                    throw error;
+                },
+                count: retryCount
+            }))
+                .subscribe(data => {
+                resolve(data);
+                // provide 3ms slacktime before releasing observable.
+                setTimeout(() => {
+                    o.unsubscribe();
+                }, 3);
+            });
+        });
+        return p;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: Fetch, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: Fetch, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: Fetch, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fetch.service.js","sourceRoot":"","sources":["../../../../packages/common/core/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\n        let abort = false;\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                        abort = true;\n\n                        reject(error);\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"]}