@dotglitch/ngx-common 1.0.2

package/esm2020/directives/menu.directive.mjs

@@ -0,0 +1,112 @@
+import { Directive, Input } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { getPosition } from './utils';
+import { MenuComponent, calcMenuItemBounds } from '../components/menu/menu.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+export class MenuDirective {
+    constructor(dialog, viewContainer) {
+        this.dialog = dialog;
+        this.viewContainer = viewContainer;
+        /**
+         * Configuration for opening the app menu
+         */
+        this.config = {};
+    }
+    ngAfterViewInit() {
+        const el = this.viewContainer.element.nativeElement;
+        // Automatically attach context menu items to
+        // the contextmenu event
+        if (this.ctxMenuItems) {
+            el.onclick = this.openMenu.bind(this);
+            el.addEventListener('contextmenu', (e) => {
+                e.preventDefault();
+                this.openMenu(e);
+            });
+        }
+        if (!this.config?.trigger) {
+            el.onclick = this.openMenu.bind(this);
+            el.addEventListener('click', this.openMenu.bind(this));
+        }
+        else {
+            const triggers = Array.isArray(this.config.trigger) ? this.config.trigger : [this.config.trigger];
+            triggers.forEach(t => {
+                if (t == "contextmenu") {
+                    el.addEventListener(t, (e) => {
+                        e.preventDefault();
+                        this.openMenu(e);
+                    });
+                }
+                else {
+                    el.addEventListener(t, this.openMenu.bind(this));
+                }
+            });
+        }
+    }
+    async openMenu(evt) {
+        const el = this.viewContainer.element.nativeElement;
+        el.classList.add("ngx-menu-open");
+        return openMenu(this.dialog, this.menuItems, this.data, evt, this.config)
+            .then((...res) => {
+            el.classList.remove("ngx-menu-open");
+            return res;
+        })
+            .catch((ex) => {
+            el.classList.remove("ngx-menu-open");
+            throw ex;
+        });
+    }
+}
+MenuDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MenuDirective, deps: [{ token: i1.MatDialog }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+MenuDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: MenuDirective, isStandalone: true, selector: "[ngx-ctxmenu],[ngx-menu]", inputs: { data: ["ngx-menu-context", "data"], ctxMenuItems: ["ngx-ctxmenu", "ctxMenuItems"], menuItems: ["ngx-menu", "menuItems"], config: ["ngx-menu-config", "config"] }, providers: [
+        MatDialog
+    ], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MenuDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ngx-ctxmenu],[ngx-menu]',
+                    providers: [
+                        MatDialog
+                    ],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }, { type: i0.ViewContainerRef }]; }, propDecorators: { data: [{
+                type: Input,
+                args: ["ngx-menu-context"]
+            }], ctxMenuItems: [{
+                type: Input,
+                args: ["ngx-ctxmenu"]
+            }], menuItems: [{
+                type: Input,
+                args: ["ngx-menu"]
+            }], config: [{
+                type: Input,
+                args: ["ngx-menu-config"]
+            }] } });
+// Helper to open the context menu without using the directive.
+export const openMenu = async (dialog, menuItems, data, evt, config = {}) => {
+    evt.preventDefault();
+    evt.stopPropagation();
+    const cords = getPosition(evt, config, await calcMenuItemBounds(menuItems, data));
+    const specificId = crypto.randomUUID();
+    if (!config.alignment)
+        config.alignment = "start";
+    return new Promise(res => {
+        dialog.open(MenuComponent, {
+            data: {
+                data: data,
+                items: menuItems,
+                config: config,
+                id: specificId
+            },
+            panelClass: ["ngx-menu", 'ngx-' + specificId].concat(config?.customClass || []),
+            position: cords,
+            backdropClass: "ngx-menu-backdrop"
+        })
+            .afterClosed()
+            .subscribe(s => {
+            res(s);
+        });
+    });
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu.directive.js","sourceRoot":"","sources":["../../../../packages/common/src/directives/menu.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Input, ViewContainerRef } from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { getPosition } from './utils';\nimport { MenuItem, MenuOptions } from '../types/menu';\nimport { MenuComponent, calcMenuItemBounds } from '../components/menu/menu.component';\n\n@Directive({\n    selector: '[ngx-ctxmenu],[ngx-menu]',\n    providers: [\n        MatDialog\n    ],\n    standalone: true\n})\nexport class MenuDirective {\n\n    /**\n     * The data representing the item the menu was opened for.\n     */\n    @Input(\"ngx-menu-context\") data: any;\n\n    /**\n     * The items that will be bound to the context menu.\n     */\n    @Input(\"ngx-ctxmenu\") ctxMenuItems: MenuItem[];\n    @Input(\"ngx-menu\") menuItems: MenuItem[];\n\n    /**\n     * Configuration for opening the app menu\n     */\n    @Input(\"ngx-menu-config\") config: MenuOptions = {};\n\n    constructor(\n        private dialog: MatDialog,\n        private viewContainer: ViewContainerRef\n    ) { }\n\n    ngAfterViewInit() {\n        const el = this.viewContainer.element.nativeElement as HTMLElement;\n\n        // Automatically attach context menu items to\n        // the contextmenu event\n        if (this.ctxMenuItems) {\n            el.onclick = this.openMenu.bind(this);\n            el.addEventListener('contextmenu', (e) => {\n                e.preventDefault();\n                this.openMenu(e as any);\n            });\n        }\n\n        if (!this.config?.trigger) {\n            el.onclick = this.openMenu.bind(this);\n            el.addEventListener('click', this.openMenu.bind(this));\n        }\n        else {\n            const triggers = Array.isArray(this.config.trigger) ? this.config.trigger : [this.config.trigger];\n\n            triggers.forEach(t => {\n                if (t == \"contextmenu\") {\n                    el.addEventListener(t, (e) => {\n                        e.preventDefault();\n                        this.openMenu(e as any);\n                    });\n                }\n                else {\n                    el.addEventListener(t, this.openMenu.bind(this));\n                }\n            });\n        }\n    }\n\n    async openMenu(evt: PointerEvent) {\n        const el = this.viewContainer.element.nativeElement as HTMLElement;\n\n        el.classList.add(\"ngx-menu-open\");\n\n        return openMenu(this.dialog, this.menuItems, this.data, evt, this.config)\n            .then((...res) => {\n                el.classList.remove(\"ngx-menu-open\");\n                return res;\n            })\n            .catch((ex) => {\n                el.classList.remove(\"ngx-menu-open\");\n                throw ex;\n            });\n    }\n}\n\n// Helper to open the context menu without using the directive.\nexport const openMenu = async (dialog: MatDialog, menuItems: MenuItem[], data: any, evt: PointerEvent, config: MenuOptions = {}) => {\n    evt.preventDefault();\n    evt.stopPropagation();\n\n    const cords = getPosition(evt, config, await calcMenuItemBounds(menuItems, data));\n    const specificId = crypto.randomUUID();\n\n    if (!config.alignment) config.alignment = \"start\";\n\n    return new Promise(res => {\n        dialog.open(MenuComponent, {\n            data: {\n                data: data,\n                items: menuItems,\n                config: config,\n                id: specificId\n            },\n            panelClass: [\"ngx-menu\", 'ngx-' + specificId].concat(config?.customClass || []),\n            position: cords,\n            backdropClass: \"ngx-menu-backdrop\"\n        })\n        .afterClosed()\n        .subscribe(s => {\n            res(s);\n        })\n    }) as Promise<any>;\n};\n"]}

package/esm2020/directives/tooltip.directive.mjs

@@ -0,0 +1,92 @@
+import { Directive, Input, HostListener, TemplateRef } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { getPosition } from './utils';
+import { TooltipComponent, calcTooltipBounds } from '../components/tooltip/tooltip.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+export class TooltipDirective {
+    constructor(dialog, viewContainer) {
+        this.dialog = dialog;
+        this.viewContainer = viewContainer;
+        /**
+         * Configuration for opening the app menu
+         */
+        this.config = {};
+        /**
+         * Arbitrary data to pass into the template
+         */
+        this.data = {};
+    }
+    ngOnInit() {
+    }
+    // Needs to be public so we can manually open the dialog
+    async onPointerEnter(evt) {
+        // If the template is not a template ref, do nothing.
+        if (!(this.template instanceof TemplateRef))
+            return;
+        const el = this.viewContainer.element.nativeElement;
+        this.dialogInstance = await openTooltip(this.dialog, this.template, this.data, el, this.config);
+    }
+}
+TooltipDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TooltipDirective, deps: [{ token: i1.MatDialog }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+TooltipDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: TooltipDirective, isStandalone: true, selector: "[ngxTooltip],[ngx-tooltip]", inputs: { template: ["ngx-tooltip", "template"], config: ["ngx-tooltip-config", "config"], data: ["ngx-tooltip-context", "data"] }, host: { listeners: { "pointerenter": "onPointerEnter($event)" } }, providers: [
+        MatDialog
+    ], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TooltipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ngxTooltip],[ngx-tooltip]',
+                    providers: [
+                        MatDialog
+                    ],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }, { type: i0.ViewContainerRef }]; }, propDecorators: { template: [{
+                type: Input,
+                args: ["ngxTooltip"]
+            }, {
+                type: Input,
+                args: ["ngx-tooltip"]
+            }], config: [{
+                type: Input,
+                args: ["ngxTooltipConfig"]
+            }, {
+                type: Input,
+                args: ["ngx-tooltip-config"]
+            }], data: [{
+                type: Input,
+                args: ["ngxTooltipContext"]
+            }, {
+                type: Input,
+                args: ["ngx-tooltip-context"]
+            }], onPointerEnter: [{
+                type: HostListener,
+                args: ['pointerenter', ['$event']]
+            }] } });
+// Helper to open the context menu without using the directive.
+export const openTooltip = async (dialog, template, data, el, config) => {
+    const rect = await calcTooltipBounds(template, data);
+    const ownerCords = el.getBoundingClientRect();
+    const cords = getPosition(el, config, rect);
+    const specificId = crypto.randomUUID();
+    return new Promise(res => {
+        dialog.open(TooltipComponent, {
+            data: {
+                data: data,
+                template: template,
+                config: config,
+                ownerCords: ownerCords,
+                selfCords: cords,
+                id: specificId
+            },
+            panelClass: ["ngx-tooltip", 'ngx-' + specificId].concat(config?.customClass || []),
+            position: cords,
+            hasBackdrop: false
+        })
+            .afterClosed()
+            .subscribe(s => {
+            res(s);
+        });
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/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/src/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/esm2020/dotglitch-ngx-common.mjs

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

package/esm2020/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);
+    }
+}
+HtmlBypass.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HtmlBypass, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
+HtmlBypass.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: HtmlBypass, isStandalone: true, name: "htmlbypass" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HtmlBypass, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'htmlbypass',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHRtbC1ieXBhc3MucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbW1vbi9zcmMvcGlwZXMvaHRtbC1ieXBhc3MucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFrQyxNQUFNLGVBQWUsQ0FBQzs7O0FBR3JFOzs7OztHQUtHO0FBS0gsTUFBTSxPQUFPLFVBQVU7SUFFbkIsWUFBb0IsU0FBdUI7UUFBdkIsY0FBUyxHQUFULFNBQVMsQ0FBYztJQUFJLENBQUM7SUFFekMsU0FBUyxDQUFDLEdBQVc7UUFDeEIsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLHVCQUF1QixDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ3ZELENBQUM7O3VHQU5RLFVBQVU7cUdBQVYsVUFBVTsyRkFBVixVQUFVO2tCQUp0QixJQUFJO21CQUFDO29CQUNGLElBQUksRUFBRSxZQUFZO29CQUNsQixVQUFVLEVBQUUsSUFBSTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtLCBTZWN1cml0eUNvbnRleHQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IERvbVNhbml0aXplciwgU2FmZVVybCB9IGZyb20gJ0Bhbmd1bGFyL3BsYXRmb3JtLWJyb3dzZXInO1xuXG4vKipcbiAqIFVybCBTYW5pdGl6ZXIgcGlwZS5cbiAqXG4gKiBUaGlzIHRydXN0cyBVUkxzIHRoYXQgZXhpc3QgaW4gYSBzYWZlIGxpc3QgZGVmaW5lZCBpbiBvdXIgZW52aXJvbm1lbnRzLnRzIGZpbGUuXG4gKiBBbnkgb3RoZXIgVVJMcyB3aWxsIE5PVCBiZSB0cnVzdGVkLCB0aHVzIHdpbGwgbm90IGJlIGxvYWRlZC5cbiAqL1xuQFBpcGUoe1xuICAgIG5hbWU6ICdodG1sYnlwYXNzJyxcbiAgICBzdGFuZGFsb25lOiB0cnVlXG59KVxuZXhwb3J0IGNsYXNzIEh0bWxCeXBhc3MgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcblxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgc2FuaXRpemVyOiBEb21TYW5pdGl6ZXIpIHsgfVxuXG4gICAgcHVibGljIHRyYW5zZm9ybSh1cmw6IHN0cmluZyk6IFNhZmVVcmwge1xuICAgICAgICByZXR1cm4gdGhpcy5zYW5pdGl6ZXIuYnlwYXNzU2VjdXJpdHlUcnVzdEh0bWwodXJsKTtcbiAgICB9XG59XG4iXX0=

package/esm2020/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);
+    }
+}
+ResourceBypass.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ResourceBypass, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
+ResourceBypass.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: ResourceBypass, isStandalone: true, name: "resourcebypass" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ResourceBypass, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'resourcebypass',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb3VyY2UtYnlwYXNzLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vc3JjL3BpcGVzL3Jlc291cmNlLWJ5cGFzcy5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWtDLE1BQU0sZUFBZSxDQUFDOzs7QUFHckU7Ozs7O0dBS0c7QUFLSCxNQUFNLE9BQU8sY0FBYztJQUV2QixZQUFvQixTQUF1QjtRQUF2QixjQUFTLEdBQVQsU0FBUyxDQUFjO0lBQUksQ0FBQztJQUV6QyxTQUFTLENBQUMsR0FBVztRQUN4QixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsOEJBQThCLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDOUQsQ0FBQzs7MkdBTlEsY0FBYzt5R0FBZCxjQUFjOzJGQUFkLGNBQWM7a0JBSjFCLElBQUk7bUJBQUM7b0JBQ0YsSUFBSSxFQUFFLGdCQUFnQjtvQkFDdEIsVUFBVSxFQUFFLElBQUk7aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSwgU2VjdXJpdHlDb250ZXh0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEb21TYW5pdGl6ZXIsIFNhZmVVcmwgfSBmcm9tICdAYW5ndWxhci9wbGF0Zm9ybS1icm93c2VyJztcblxuLyoqXG4gKiBVcmwgU2FuaXRpemVyIHBpcGUuXG4gKlxuICogVGhpcyB0cnVzdHMgVVJMcyB0aGF0IGV4aXN0IGluIGEgc2FmZSBsaXN0IGRlZmluZWQgaW4gb3VyIGVudmlyb25tZW50cy50cyBmaWxlLlxuICogQW55IG90aGVyIFVSTHMgd2lsbCBOT1QgYmUgdHJ1c3RlZCwgdGh1cyB3aWxsIG5vdCBiZSBsb2FkZWQuXG4gKi9cbkBQaXBlKHtcbiAgICBuYW1lOiAncmVzb3VyY2VieXBhc3MnLFxuICAgIHN0YW5kYWxvbmU6IHRydWVcbn0pXG5leHBvcnQgY2xhc3MgUmVzb3VyY2VCeXBhc3MgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcblxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgc2FuaXRpemVyOiBEb21TYW5pdGl6ZXIpIHsgfVxuXG4gICAgcHVibGljIHRyYW5zZm9ybSh1cmw6IHN0cmluZyk6IFNhZmVVcmwge1xuICAgICAgICByZXR1cm4gdGhpcy5zYW5pdGl6ZXIuYnlwYXNzU2VjdXJpdHlUcnVzdFJlc291cmNlVXJsKHVybCk7XG4gICAgfVxufVxuIl19

package/esm2020/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);
+    }
+}
+ScriptBypass.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ScriptBypass, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
+ScriptBypass.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: ScriptBypass, isStandalone: true, name: "scriptbypass" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ScriptBypass, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'scriptbypass',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NyaXB0LWJ5cGFzcy5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tbW9uL3NyYy9waXBlcy9zY3JpcHQtYnlwYXNzLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBa0MsTUFBTSxlQUFlLENBQUM7OztBQUdyRTs7Ozs7R0FLRztBQUtILE1BQU0sT0FBTyxZQUFZO0lBRXJCLFlBQW9CLFNBQXVCO1FBQXZCLGNBQVMsR0FBVCxTQUFTLENBQWM7SUFBSSxDQUFDO0lBRXpDLFNBQVMsQ0FBQyxHQUFXO1FBQ3hCLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyx5QkFBeUIsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUN6RCxDQUFDOzt5R0FOUSxZQUFZO3VHQUFaLFlBQVk7MkZBQVosWUFBWTtrQkFKeEIsSUFBSTttQkFBQztvQkFDRixJQUFJLEVBQUUsY0FBYztvQkFDcEIsVUFBVSxFQUFFLElBQUk7aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSwgU2VjdXJpdHlDb250ZXh0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEb21TYW5pdGl6ZXIsIFNhZmVVcmwgfSBmcm9tICdAYW5ndWxhci9wbGF0Zm9ybS1icm93c2VyJztcblxuLyoqXG4gKiBVcmwgU2FuaXRpemVyIHBpcGUuXG4gKlxuICogVGhpcyB0cnVzdHMgVVJMcyB0aGF0IGV4aXN0IGluIGEgc2FmZSBsaXN0IGRlZmluZWQgaW4gb3VyIGVudmlyb25tZW50cy50cyBmaWxlLlxuICogQW55IG90aGVyIFVSTHMgd2lsbCBOT1QgYmUgdHJ1c3RlZCwgdGh1cyB3aWxsIG5vdCBiZSBsb2FkZWQuXG4gKi9cbkBQaXBlKHtcbiAgICBuYW1lOiAnc2NyaXB0YnlwYXNzJyxcbiAgICBzdGFuZGFsb25lOiB0cnVlXG59KVxuZXhwb3J0IGNsYXNzIFNjcmlwdEJ5cGFzcyBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSBzYW5pdGl6ZXI6IERvbVNhbml0aXplcikgeyB9XG5cbiAgICBwdWJsaWMgdHJhbnNmb3JtKHVybDogc3RyaW5nKTogU2FmZVVybCB7XG4gICAgICAgIHJldHVybiB0aGlzLnNhbml0aXplci5ieXBhc3NTZWN1cml0eVRydXN0U2NyaXB0KHVybCk7XG4gICAgfVxufVxuIl19

package/esm2020/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);
+    }
+}
+StyleBypass.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: StyleBypass, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
+StyleBypass.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: StyleBypass, isStandalone: true, name: "stylebypass" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: StyleBypass, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'stylebypass',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3R5bGUtYnlwYXNzLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vc3JjL3BpcGVzL3N0eWxlLWJ5cGFzcy5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWtDLE1BQU0sZUFBZSxDQUFDOzs7QUFHckU7Ozs7O0dBS0c7QUFLSCxNQUFNLE9BQU8sV0FBVztJQUVwQixZQUFvQixTQUF1QjtRQUF2QixjQUFTLEdBQVQsU0FBUyxDQUFjO0lBQUksQ0FBQztJQUV6QyxTQUFTLENBQUMsR0FBVztRQUN4QixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsd0JBQXdCLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDeEQsQ0FBQzs7d0dBTlEsV0FBVztzR0FBWCxXQUFXOzJGQUFYLFdBQVc7a0JBSnZCLElBQUk7bUJBQUM7b0JBQ0YsSUFBSSxFQUFFLGFBQWE7b0JBQ25CLFVBQVUsRUFBRSxJQUFJO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0sIFNlY3VyaXR5Q29udGV4dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRG9tU2FuaXRpemVyLCBTYWZlVXJsIH0gZnJvbSAnQGFuZ3VsYXIvcGxhdGZvcm0tYnJvd3Nlcic7XG5cbi8qKlxuICogVXJsIFNhbml0aXplciBwaXBlLlxuICpcbiAqIFRoaXMgdHJ1c3RzIFVSTHMgdGhhdCBleGlzdCBpbiBhIHNhZmUgbGlzdCBkZWZpbmVkIGluIG91ciBlbnZpcm9ubWVudHMudHMgZmlsZS5cbiAqIEFueSBvdGhlciBVUkxzIHdpbGwgTk9UIGJlIHRydXN0ZWQsIHRodXMgd2lsbCBub3QgYmUgbG9hZGVkLlxuICovXG5AUGlwZSh7XG4gICAgbmFtZTogJ3N0eWxlYnlwYXNzJyxcbiAgICBzdGFuZGFsb25lOiB0cnVlXG59KVxuZXhwb3J0IGNsYXNzIFN0eWxlQnlwYXNzIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG5cbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIHNhbml0aXplcjogRG9tU2FuaXRpemVyKSB7IH1cblxuICAgIHB1YmxpYyB0cmFuc2Zvcm0odXJsOiBzdHJpbmcpOiBTYWZlVXJsIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuc2FuaXRpemVyLmJ5cGFzc1NlY3VyaXR5VHJ1c3RTdHlsZSh1cmwpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2020/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);
+    }
+}
+UrlBypass.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: UrlBypass, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
+UrlBypass.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: UrlBypass, isStandalone: true, name: "urlbypass" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: UrlBypass, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'urlbypass',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXJsLWJ5cGFzcy5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tbW9uL3NyYy9waXBlcy91cmwtYnlwYXNzLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBa0MsTUFBTSxlQUFlLENBQUM7OztBQUdyRTs7Ozs7R0FLRztBQUtILE1BQU0sT0FBTyxTQUFTO0lBRWxCLFlBQW9CLFNBQXVCO1FBQXZCLGNBQVMsR0FBVCxTQUFTLENBQWM7SUFBSSxDQUFDO0lBRXpDLFNBQVMsQ0FBQyxHQUFXO1FBQ3hCLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxzQkFBc0IsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUN0RCxDQUFDOztzR0FOUSxTQUFTO29HQUFULFNBQVM7MkZBQVQsU0FBUztrQkFKckIsSUFBSTttQkFBQztvQkFDRixJQUFJLEVBQUUsV0FBVztvQkFDakIsVUFBVSxFQUFFLElBQUk7aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSwgU2VjdXJpdHlDb250ZXh0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEb21TYW5pdGl6ZXIsIFNhZmVVcmwgfSBmcm9tICdAYW5ndWxhci9wbGF0Zm9ybS1icm93c2VyJztcblxuLyoqXG4gKiBVcmwgU2FuaXRpemVyIHBpcGUuXG4gKlxuICogVGhpcyB0cnVzdHMgVVJMcyB0aGF0IGV4aXN0IGluIGEgc2FmZSBsaXN0IGRlZmluZWQgaW4gb3VyIGVudmlyb25tZW50cy50cyBmaWxlLlxuICogQW55IG90aGVyIFVSTHMgd2lsbCBOT1QgYmUgdHJ1c3RlZCwgdGh1cyB3aWxsIG5vdCBiZSBsb2FkZWQuXG4gKi9cbkBQaXBlKHtcbiAgICBuYW1lOiAndXJsYnlwYXNzJyxcbiAgICBzdGFuZGFsb25lOiB0cnVlXG59KVxuZXhwb3J0IGNsYXNzIFVybEJ5cGFzcyBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSBzYW5pdGl6ZXI6IERvbVNhbml0aXplcikgeyB9XG5cbiAgICBwdWJsaWMgdHJhbnNmb3JtKHVybDogc3RyaW5nKTogU2FmZVVybCB7XG4gICAgICAgIHJldHVybiB0aGlzLnNhbml0aXplci5ieXBhc3NTZWN1cml0eVRydXN0VXJsKHVybCk7XG4gICAgfVxufVxuIl19

package/esm2020/public-api.mjs

@@ -0,0 +1,39 @@
+/*
+ * Public API Surface of package
+ */
+/**
+ ** Directives
+ */
+export * from './directives/tooltip.directive';
+export * from './directives/menu.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/keyboard.service';
+// export * from './services/serviceworker.service';
+/**
+** Lazy loader component & service
+*/
+export * from './components/lazy-loader/lazy-loader.service';
+export * from './components/lazy-loader/lazy-loader.module';
+export * from './components/lazy-loader/lazy-loader.component';
+export * from './components/lazy-loader/types';
+/**
+** Services
+*/
+export * from './components/dynamic-html/dynamic-html.service';
+export * from './components/dynamic-html/dynamic-html.module';
+export * from './components/dynamic-html/dynamic-html.component';
+export * from './components/dynamic-html/types';
+//# sourceMappingURL=data:application/json;base64,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