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

package/esm2022/core/components/menu/menu.directive.mjs

@@ -0,0 +1,159 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { firstValueFrom } from 'rxjs';
+import { ulid } from 'ulidx';
+import { getPosition } from '../../directives/utils';
+import { MenuComponent, calcMenuItemBounds } from './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 = {};
+        this.triggers = [];
+    }
+    ngOnInit() {
+        this.ngOnChanges();
+    }
+    ngOnChanges() {
+        if (this.config.trigger) {
+            this.triggers = Array.isArray(this.config.trigger) ? this.config.trigger : [this.config.trigger];
+        }
+    }
+    ngAfterViewInit() {
+        // const el = this.viewContainer.element.nativeElement as HTMLElement;
+        // // Automatically attach context menu items to
+        // // the contextmenu event
+        // if (this.ctxMenuItems) {
+        //     el.addEventListener('contextmenu', (e) => {
+        //         e.preventDefault();
+        //         this.openMenu(e as any, this.ctxMenuItems, true);
+        //     });
+        // }
+        // if (this.menuItems?.length > 0) {
+        //     if (!this.config?.trigger) {
+        //         el.addEventListener('click', (e) => {
+        //             this.openMenu(e as any, this.menuItems, true);
+        //         });
+        //     }
+        //     else {
+        //         triggers.forEach(t => {
+        //             if (["contextmenu", "click"].includes(t)) {
+        //                 el.addEventListener(t, (e) => {
+        //                     e.preventDefault();
+        //                     this.openMenu(e as any, this.ctxMenuItems, true);
+        //                 });
+        //             }
+        //             else {
+        //                 el.addEventListener(t, this.openMenu.bind(this));
+        //             }
+        //         });
+        //     }
+        // }
+    }
+    async openMenu(evt, items = this.menuItems, keepOpen = false) {
+        const el = this.viewContainer.element.nativeElement;
+        el.classList.add("ngx-menu-open");
+        const isCtxEvent = evt.button == 2;
+        const config = structuredClone(this.config);
+        config['_isLockedOpen'] = keepOpen;
+        return openMenu(this.dialog, items, this.data, evt, this.config, isCtxEvent ? null : el)
+            .then((...res) => {
+            el.classList.remove("ngx-menu-open");
+            return res;
+        })
+            .catch((ex) => {
+            el.classList.remove("ngx-menu-open");
+            throw ex;
+        });
+    }
+    onCtxMenu(e) {
+        if (this.ctxMenuItems || this.triggers.includes("contextmenu")) {
+            e.preventDefault();
+            this.openMenu(e, this.ctxMenuItems, true);
+        }
+    }
+    onClick(e) {
+        if (this.menuItems &&
+            (this.triggers.length == 0 ||
+                this.triggers.includes("click"))) {
+            e.preventDefault();
+            this.openMenu(e, this.menuItems, true);
+        }
+    }
+    onDblClick(e) {
+        if (this.menuItems && this.triggers.length == 0 ||
+            this.menuItems && this.triggers.includes("dblclick")) {
+            e.preventDefault();
+            this.openMenu(e, this.menuItems, true);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MenuDirective, deps: [{ token: i1.MatDialog }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: MenuDirective, isStandalone: true, selector: "[ngx-contextmenu],[ngx-menu]", inputs: { data: ["ngx-menu-context", "data"], ctxMenuItems: ["ngx-contextmenu", "ctxMenuItems"], menuItems: ["ngx-menu", "menuItems"], config: ["ngx-menu-config", "config"] }, host: { listeners: { "contextmenu": "onCtxMenu($event)", "click": "onClick($event)", "dblclick": "onDblClick($event)" } }, providers: [
+            MatDialog
+        ], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MenuDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ngx-contextmenu],[ngx-menu]',
+                    providers: [
+                        MatDialog
+                    ],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.MatDialog }, { type: i0.ViewContainerRef }], propDecorators: { data: [{
+                type: Input,
+                args: ["ngx-menu-context"]
+            }], ctxMenuItems: [{
+                type: Input,
+                args: ["ngx-contextmenu"]
+            }], menuItems: [{
+                type: Input,
+                args: ["ngx-menu"]
+            }], config: [{
+                type: Input,
+                args: ["ngx-menu-config"]
+            }], onCtxMenu: [{
+                type: HostListener,
+                args: ["contextmenu", ['$event']]
+            }], onClick: [{
+                type: HostListener,
+                args: ["click", ['$event']]
+            }], onDblClick: [{
+                type: HostListener,
+                args: ["dblclick", ['$event']]
+            }] } });
+// Helper to open the menu without using the directive.
+export const openMenu = async (dialog, menuItems, data, evt, config = {}, el) => {
+    // console.log({ dialog, menuItems, data, evt, config, el });
+    evt.preventDefault();
+    evt.stopPropagation();
+    // Apply defaults.
+    if (!config.alignment)
+        config.alignment = "start";
+    const initialBounds = await calcMenuItemBounds(menuItems, data);
+    const cords = getPosition(el || evt, config, initialBounds);
+    const specificId = ulid();
+    return firstValueFrom(dialog.open(MenuComponent, {
+        data: {
+            dialog,
+            data: data,
+            ownerCords: el?.getBoundingClientRect(),
+            selfCords: cords,
+            items: menuItems,
+            config: config,
+            id: specificId,
+            targetBounds: initialBounds
+        },
+        panelClass: ["ngx-menu", 'ngx-' + specificId].concat(config?.customClass || []),
+        position: cords,
+        backdropClass: "ngx-menu-backdrop"
+    })
+        .afterClosed());
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu.directive.js","sourceRoot":"","sources":["../../../../../packages/common/core/components/menu/menu.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAoB,MAAM,eAAe,CAAC;AACjF,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAC7B,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;;;AAUrE,MAAM,OAAO,aAAa;IAyBtB,YACY,MAAiB,EACjB,aAA+B;QAD/B,WAAM,GAAN,MAAM,CAAW;QACjB,kBAAa,GAAb,aAAa,CAAkB;QAT3C;;WAEG;QACuB,WAAM,GAAgB,EAAE,CAAC;QAE3C,aAAQ,GAAa,EAAE,CAAC;IAK5B,CAAC;IAEL,QAAQ;QACJ,IAAI,CAAC,WAAW,EAAE,CAAC;IACvB,CAAC;IAED,WAAW;QAEP,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACtB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACrG,CAAC;IACL,CAAC;IAED,eAAe;QACX,sEAAsE;QAEtE,gDAAgD;QAChD,2BAA2B;QAC3B,2BAA2B;QAC3B,kDAAkD;QAClD,8BAA8B;QAC9B,4DAA4D;QAC5D,UAAU;QACV,IAAI;QAEJ,oCAAoC;QACpC,mCAAmC;QACnC,gDAAgD;QAChD,6DAA6D;QAC7D,cAAc;QACd,QAAQ;QACR,aAAa;QAEb,kCAAkC;QAClC,0DAA0D;QAC1D,kDAAkD;QAClD,0CAA0C;QAC1C,wEAAwE;QACxE,sBAAsB;QACtB,gBAAgB;QAChB,qBAAqB;QACrB,oEAAoE;QACpE,gBAAgB;QAChB,cAAc;QACd,QAAQ;QACR,IAAI;IACR,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,GAAiB,EAAE,KAAK,GAAG,IAAI,CAAC,SAAS,EAAE,QAAQ,GAAG,KAAK;QACtE,MAAM,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,aAA4B,CAAC;QAEnE,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAElC,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC;QAEnC,MAAM,MAAM,GAAG,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC5C,MAAM,CAAC,eAAe,CAAC,GAAG,QAAQ,CAAC;QAEnC,OAAO,QAAQ,CACX,IAAI,CAAC,MAAM,EACX,KAAK,EACL,IAAI,CAAC,IAAI,EACT,GAAG,EACH,IAAI,CAAC,MAAM,EACX,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CACzB;aACI,IAAI,CAAC,CAAC,GAAG,GAAG,EAAE,EAAE;YACb,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;YACrC,OAAO,GAAG,CAAC;QACf,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE;YACV,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;YACrC,MAAM,EAAE,CAAC;QACb,CAAC,CAAC,CAAC;IACX,CAAC;IAGD,SAAS,CAAC,CAAC;QACP,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;YAC7D,CAAC,CAAC,cAAc,EAAE,CAAC;YACnB,IAAI,CAAC,QAAQ,CAAC,CAAQ,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;QACrD,CAAC;IACL,CAAC;IAGD,OAAO,CAAC,CAAC;QACL,IACI,IAAI,CAAC,SAAS;YACd,CACI,IAAI,CAAC,QAAQ,CAAC,MAAM,IAAI,CAAC;gBACzB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAClC,EACH,CAAC;YACC,CAAC,CAAC,cAAc,EAAE,CAAC;YACnB,IAAI,CAAC,QAAQ,CAAC,CAAQ,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QAClD,CAAC;IACL,CAAC;IAGD,UAAU,CAAC,CAAC;QACR,IACI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,IAAI,CAAC;YAC3C,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,EACtD,CAAC;YACC,CAAC,CAAC,cAAc,EAAE,CAAC;YACnB,IAAI,CAAC,QAAQ,CAAC,CAAQ,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QAClD,CAAC;IACL,CAAC;+GAvIQ,aAAa;mGAAb,aAAa,sXALX;YACP,SAAS;SACZ;;4FAGQ,aAAa;kBAPzB,SAAS;mBAAC;oBACP,QAAQ,EAAE,8BAA8B;oBACxC,SAAS,EAAE;wBACP,SAAS;qBACZ;oBACD,UAAU,EAAE,IAAI;iBACnB;6GAM8B,IAAI;sBAA9B,KAAK;uBAAC,kBAAkB;gBAKC,YAAY;sBAArC,KAAK;uBAAC,iBAAiB;gBAML,SAAS;sBAA3B,KAAK;uBAAC,UAAU;gBAKS,MAAM;sBAA/B,KAAK;uBAAC,iBAAiB;gBAoFxB,SAAS;sBADR,YAAY;uBAAC,aAAa,EAAE,CAAC,QAAQ,CAAC;gBASvC,OAAO;sBADN,YAAY;uBAAC,OAAO,EAAE,CAAC,QAAQ,CAAC;gBAejC,UAAU;sBADT,YAAY;uBAAC,UAAU,EAAE,CAAC,QAAQ,CAAC;;AAYxC,uDAAuD;AACvD,MAAM,CAAC,MAAM,QAAQ,GAAG,KAAK,EACzB,MAAiB,EACjB,SAAqB,EACrB,IAAS,EACT,GAAiB,EACjB,SAAsB,EAAE,EACxB,EAAgB,EAClB,EAAE;IACA,6DAA6D;IAE7D,GAAG,CAAC,cAAc,EAAE,CAAC;IACrB,GAAG,CAAC,eAAe,EAAE,CAAC;IAEtB,kBAAkB;IAClB,IAAI,CAAC,MAAM,CAAC,SAAS;QACjB,MAAM,CAAC,SAAS,GAAG,OAAO,CAAC;IAE/B,MAAM,aAAa,GAAG,MAAM,kBAAkB,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAChE,MAAM,KAAK,GAAG,WAAW,CAAC,EAAE,IAAI,GAAG,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC;IAC5D,MAAM,UAAU,GAAG,IAAI,EAAE,CAAC;IAE1B,OAAO,cAAc,CACjB,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE;QACvB,IAAI,EAAE;YACF,MAAM;YACN,IAAI,EAAE,IAAI;YACV,UAAU,EAAE,EAAE,EAAE,qBAAqB,EAAE;YACvC,SAAS,EAAE,KAAK;YAChB,KAAK,EAAE,SAAS;YAChB,MAAM,EAAE,MAAM;YACd,EAAE,EAAE,UAAU;YACd,YAAY,EAAE,aAAa;SAC9B;QACD,UAAU,EAAE,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,IAAI,EAAE,CAAC;QAC/E,QAAQ,EAAE,KAAK;QACf,aAAa,EAAE,mBAAmB;KACrC,CAAC;SACG,WAAW,EAAE,CAAC,CAAC;AAC5B,CAAC,CAAC","sourcesContent":["import { Directive, HostListener, Input, ViewContainerRef } from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { firstValueFrom } from 'rxjs';\nimport { ulid } from 'ulidx';\nimport { getPosition } from '../../directives/utils';\nimport { MenuComponent, calcMenuItemBounds } from './menu.component';\nimport { MenuItem, MenuOptions } from './types';\n\n@Directive({\n    selector: '[ngx-contextmenu],[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-contextmenu\") ctxMenuItems: MenuItem[];\n\n    /**\n     * The items that will be bound to the menu that pops\n     * up when the user clicks the element.\n     */\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    private triggers: string[] = [];\n\n    constructor(\n        private dialog: MatDialog,\n        private viewContainer: ViewContainerRef\n    ) { }\n\n    ngOnInit() {\n        this.ngOnChanges();\n    }\n\n    ngOnChanges() {\n\n        if (this.config.trigger) {\n            this.triggers = Array.isArray(this.config.trigger) ? this.config.trigger : [this.config.trigger];\n        }\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.addEventListener('contextmenu', (e) => {\n        //         e.preventDefault();\n        //         this.openMenu(e as any, this.ctxMenuItems, true);\n        //     });\n        // }\n\n        // if (this.menuItems?.length > 0) {\n        //     if (!this.config?.trigger) {\n        //         el.addEventListener('click', (e) => {\n        //             this.openMenu(e as any, this.menuItems, true);\n        //         });\n        //     }\n        //     else {\n\n        //         triggers.forEach(t => {\n        //             if ([\"contextmenu\", \"click\"].includes(t)) {\n        //                 el.addEventListener(t, (e) => {\n        //                     e.preventDefault();\n        //                     this.openMenu(e as any, this.ctxMenuItems, true);\n        //                 });\n        //             }\n        //             else {\n        //                 el.addEventListener(t, this.openMenu.bind(this));\n        //             }\n        //         });\n        //     }\n        // }\n    }\n\n    async openMenu(evt: PointerEvent, items = this.menuItems, keepOpen = false) {\n        const el = this.viewContainer.element.nativeElement as HTMLElement;\n\n        el.classList.add(\"ngx-menu-open\");\n\n        const isCtxEvent = evt.button == 2;\n\n        const config = structuredClone(this.config);\n        config['_isLockedOpen'] = keepOpen;\n\n        return openMenu(\n            this.dialog,\n            items,\n            this.data,\n            evt,\n            this.config,\n            isCtxEvent ? null : el\n        )\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    @HostListener(\"contextmenu\", ['$event'])\n    onCtxMenu(e) {\n        if (this.ctxMenuItems || this.triggers.includes(\"contextmenu\")) {\n            e.preventDefault();\n            this.openMenu(e as any, this.ctxMenuItems, true);\n        }\n    }\n\n    @HostListener(\"click\", ['$event'])\n    onClick(e) {\n        if (\n            this.menuItems &&\n            (\n                this.triggers.length == 0 ||\n                this.triggers.includes(\"click\")\n            )\n        ) {\n            e.preventDefault();\n            this.openMenu(e as any, this.menuItems, true);\n        }\n    }\n\n    @HostListener(\"dblclick\", ['$event'])\n    onDblClick(e) {\n        if (\n            this.menuItems && this.triggers.length == 0 ||\n            this.menuItems && this.triggers.includes(\"dblclick\")\n        ) {\n            e.preventDefault();\n            this.openMenu(e as any, this.menuItems, true);\n        }\n    }\n}\n\n// Helper to open the menu without using the directive.\nexport const openMenu = async (\n    dialog: MatDialog,\n    menuItems: MenuItem[],\n    data: any,\n    evt: PointerEvent,\n    config: MenuOptions = {},\n    el?: HTMLElement\n) => {\n    // console.log({ dialog, menuItems, data, evt, config, el });\n\n    evt.preventDefault();\n    evt.stopPropagation();\n\n    // Apply defaults.\n    if (!config.alignment)\n        config.alignment = \"start\";\n\n    const initialBounds = await calcMenuItemBounds(menuItems, data);\n    const cords = getPosition(el || evt, config, initialBounds);\n    const specificId = ulid();\n\n    return firstValueFrom(\n        dialog.open(MenuComponent, {\n            data: {\n                dialog,\n                data: data,\n                ownerCords: el?.getBoundingClientRect(),\n                selfCords: cords,\n                items: menuItems,\n                config: config,\n                id: specificId,\n                targetBounds: initialBounds\n            },\n            panelClass: [\"ngx-menu\", 'ngx-' + specificId].concat(config?.customClass || []),\n            position: cords,\n            backdropClass: \"ngx-menu-backdrop\"\n        })\n            .afterClosed());\n};\n"]}

package/esm2022/core/components/menu/types.mjs

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

package/esm2022/core/components/parallax-card/parallax-card.component.mjs

@@ -0,0 +1,138 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { Component, ContentChild, EventEmitter, Input, Output, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ParallaxCardComponent {
+    get wrapper() { return this.element.nativeElement; }
+    get cardFront() { return this.wrapper.querySelector('.card.front'); }
+    get cardBack() { return this.wrapper.querySelector('.card.backface'); }
+    get backgroundElement() { return this.cardFront.querySelector('.card-bg'); }
+    get backfaceBackgroundElement() { return this.cardBack.querySelector('.card-bg'); }
+    constructor(element, ngZone) {
+        this.element = element;
+        this.ngZone = ngZone;
+        /**
+         *
+         */
+        this.loaded = new EventEmitter();
+        /**
+         * Width of the card
+         * @default `240px`
+         */
+        this.width = '240px';
+        /**
+         * Height of the card
+         * @default `320px`
+         */
+        this.height = '320px';
+        /**
+         * Inset padding of the parallax
+         * @default 80
+         */
+        this.bgInset = 80;
+        /**
+         * Duration for the flip animation in ms
+         * @default 1200
+         */
+        this.flipAnimationDuration = 1200;
+        this.renderCardFront = true;
+        this.renderCardBack = true;
+        this.showBackOfCard = false;
+        this.pointerX = 0;
+        this.pointerY = 0;
+        this.pointerLeave = 0;
+        this.render = () => {
+            const { width, height } = this.wrapper.getBoundingClientRect();
+            const mousePX = this.pointerX / width;
+            const mousePY = this.pointerY / height;
+            // Rotation factors
+            const rX = mousePX * this.bgInset / 1.75;
+            const rY = mousePY * -this.bgInset / 1.75;
+            // Translation factors
+            const tX = mousePX * -this.bgInset * 2;
+            const tY = mousePY * -this.bgInset * 2;
+            if (this.renderCardFront) {
+                this.backgroundElement.style.transform = `translateX(${tX}px) translateY(${tY}px)`;
+            }
+            if (this.renderCardBack) {
+                this.backfaceBackgroundElement.style.transform = `translateX(${tX}px) translateY(${tY}px)`;
+            }
+            if (this.showBackOfCard) {
+                this.cardFront.style.transform = `rotateY(180deg) rotateX(${-rY}deg)`;
+                this.cardBack.style.transform = `rotateY(${-rX}deg) rotateX(${-rY}deg)`;
+            }
+            else {
+                this.cardFront.style.transform = `rotateY(${rX}deg) rotateX(${rY}deg)`;
+                this.cardBack.style.transform = `rotateY(180deg) rotateX(${-rY}deg)`;
+            }
+        };
+    }
+    ngAfterViewInit() {
+        const el = this.wrapper;
+        this.ngZone.runOutsideAngular(() => {
+            // Directly attach events to the wrapper
+            el.onpointermove = (e) => this.onPointerMove(e);
+            el.onpointerenter = () => this.onPointerEnter();
+            el.onpointerleave = () => this.onPointerLeave();
+        });
+        el.onclick = () => this.onClick();
+        this.loaded.emit();
+    }
+    onPointerMove(e) {
+        const { width, height, left, top } = this.wrapper.getBoundingClientRect();
+        this.pointerX = e.pageX - left - (width / 2);
+        this.pointerY = e.pageY - top - (height / 2);
+        this.render();
+    }
+    onPointerEnter() {
+        clearTimeout(this.pointerLeave);
+    }
+    onPointerLeave() {
+        this.pointerLeave = setTimeout(() => {
+            this.pointerX = 0;
+            this.pointerY = 0;
+            this.render();
+        }, 600);
+    }
+    // TODO: This can get intercepted in some states
+    onClick() {
+        this.showBackOfCard = !this.showBackOfCard;
+        this.render();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ParallaxCardComponent, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: ParallaxCardComponent, isStandalone: true, selector: "ngx-parallax-card", inputs: { width: "width", height: "height", bgInset: "bgInset", flipAnimationDuration: "flipAnimationDuration" }, outputs: { loaded: "loaded" }, host: { properties: { "style.width": "width", "style.height": "height", "style.--card-bg-inset": "-bgInset+\"px\"", "style.--flip-animation-duration": "flipAnimationDuration+\"ms\"", "class.flip": "showBackOfCard" } }, queries: [{ propertyName: "content", first: true, predicate: ["content"], descendants: true, read: TemplateRef }, { propertyName: "background", first: true, predicate: ["background"], descendants: true, read: TemplateRef }, { propertyName: "backContent", first: true, predicate: ["backContent"], descendants: true, read: TemplateRef }, { propertyName: "backBackground", first: true, predicate: ["backBackground"], descendants: true, read: TemplateRef }], ngImport: i0, template: "@if (renderCardBack) {\n    <div class=\"card backface\">\n        <div class=\"card-bg\" style=\"transform: translateX(0) translateY(0)\">\n            <ng-template [ngTemplateOutlet]=\"backBackground\" />\n        </div>\n        <div class=\"card-content\">\n            <ng-template [ngTemplateOutlet]=\"backContent\" />\n        </div>\n    </div>\n}\n\n@if (renderCardFront) {\n    <div class=\"card front\">\n        <div class=\"card-bg\" style=\"transform: translateX(0) translateY(0)\">\n            <ng-template [ngTemplateOutlet]=\"background\" />\n        </div>\n        <div class=\"card-content\">\n            @if (content) {\n                <ng-template [ngTemplateOutlet]=\"content\"/>\n            }\n            @else {\n                <ng-content/>\n            }\n        </div>\n    </div>\n}\n\n\n", styles: [":host{display:block;position:relative;cursor:pointer;--easing-function: cubic-bezier(.23, 1, .32, 1);--border-radius: 9px}.card{position:absolute;height:100%;width:100%;background-color:#333;backface-visibility:hidden;overflow:hidden;box-shadow:#0000 0 0 40px 5px,#000000a8 0 30px 60px,inset #333 0 0 0 5px;border-radius:var(--border-radius);transition:transform var(--flip-animation-duration) var(--easing-function),box-shadow 2s var(--easing-function);transform-style:preserve-3d;will-change:transform}.card:hover{box-shadow:#fff6 0 0 40px 5px,#000000a8 0 30px 60px,inset #333 0 0 0 5px}.card:hover .card-content{border:2px solid #fff}.card-bg{inset:var(--card-bg-inset);position:absolute;pointer-events:none;transition:transform .6s var(--easing-function)}.card-content{position:absolute;top:0;color:#fff;height:100%;width:100%;z-index:1;border:2px solid rgba(255,255,255,0);border-radius:var(--border-radius);transition:transform .6s var(--easing-function),border-color .6s var(--easing-function)}\n"], dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ParallaxCardComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngx-parallax-card', imports: [
+                        NgTemplateOutlet
+                    ], host: {
+                        '[style.width]': 'width',
+                        '[style.height]': 'height',
+                        '[style.--card-bg-inset]': '-bgInset+"px"',
+                        '[style.--flip-animation-duration]': 'flipAnimationDuration+"ms"',
+                        '[class.flip]': 'showBackOfCard'
+                    }, standalone: true, template: "@if (renderCardBack) {\n    <div class=\"card backface\">\n        <div class=\"card-bg\" style=\"transform: translateX(0) translateY(0)\">\n            <ng-template [ngTemplateOutlet]=\"backBackground\" />\n        </div>\n        <div class=\"card-content\">\n            <ng-template [ngTemplateOutlet]=\"backContent\" />\n        </div>\n    </div>\n}\n\n@if (renderCardFront) {\n    <div class=\"card front\">\n        <div class=\"card-bg\" style=\"transform: translateX(0) translateY(0)\">\n            <ng-template [ngTemplateOutlet]=\"background\" />\n        </div>\n        <div class=\"card-content\">\n            @if (content) {\n                <ng-template [ngTemplateOutlet]=\"content\"/>\n            }\n            @else {\n                <ng-content/>\n            }\n        </div>\n    </div>\n}\n\n\n", styles: [":host{display:block;position:relative;cursor:pointer;--easing-function: cubic-bezier(.23, 1, .32, 1);--border-radius: 9px}.card{position:absolute;height:100%;width:100%;background-color:#333;backface-visibility:hidden;overflow:hidden;box-shadow:#0000 0 0 40px 5px,#000000a8 0 30px 60px,inset #333 0 0 0 5px;border-radius:var(--border-radius);transition:transform var(--flip-animation-duration) var(--easing-function),box-shadow 2s var(--easing-function);transform-style:preserve-3d;will-change:transform}.card:hover{box-shadow:#fff6 0 0 40px 5px,#000000a8 0 30px 60px,inset #333 0 0 0 5px}.card:hover .card-content{border:2px solid #fff}.card-bg{inset:var(--card-bg-inset);position:absolute;pointer-events:none;transition:transform .6s var(--easing-function)}.card-content{position:absolute;top:0;color:#fff;height:100%;width:100%;z-index:1;border:2px solid rgba(255,255,255,0);border-radius:var(--border-radius);transition:transform .6s var(--easing-function),border-color .6s var(--easing-function)}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { content: [{
+                type: ContentChild,
+                args: ['content', { read: TemplateRef }]
+            }], background: [{
+                type: ContentChild,
+                args: ['background', { read: TemplateRef }]
+            }], backContent: [{
+                type: ContentChild,
+                args: ['backContent', { read: TemplateRef }]
+            }], backBackground: [{
+                type: ContentChild,
+                args: ['backBackground', { read: TemplateRef }]
+            }], loaded: [{
+                type: Output
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], bgInset: [{
+                type: Input
+            }], flipAnimationDuration: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parallax-card.component.js","sourceRoot":"","sources":["../../../../../packages/common/core/components/parallax-card/parallax-card.component.ts","../../../../../packages/common/core/components/parallax-card/parallax-card.component.html"],"names":[],"mappings":"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","sourcesContent":["import { NgTemplateOutlet } from '@angular/common';\nimport { Component, ContentChild, ElementRef, EventEmitter, Input, NgZone, Output, TemplateRef } from '@angular/core';\n\ntype CSSUnitString = 'px' | '%' | 'em' | 'in' | '';\ntype CSSUnit = `${number}${CSSUnitString}` | `var(--${string})`;\ntype CSSString = CSSUnit |\n    `calc(${CSSUnit|''}${''|' '}${'+'|'-'|'/'|'*'}${''|' '}${CSSUnit|''})`\n\n@Component({\n    selector: 'ngx-parallax-card',\n    templateUrl: './parallax-card.component.html',\n    styleUrls: ['./parallax-card.component.scss'],\n    imports: [\n        NgTemplateOutlet\n    ],\n    host: {\n        '[style.width]': 'width',\n        '[style.height]': 'height',\n        '[style.--card-bg-inset]': '-bgInset+\"px\"',\n        '[style.--flip-animation-duration]': 'flipAnimationDuration+\"ms\"',\n        '[class.flip]': 'showBackOfCard'\n    },\n    standalone: true\n})\nexport class ParallaxCardComponent {\n\n    // Front of card\n    @ContentChild('content', { read: TemplateRef }) content: TemplateRef<ElementRef>;\n    @ContentChild('background', { read: TemplateRef }) background: TemplateRef<ElementRef>;\n\n    // Back of card\n    @ContentChild('backContent', { read: TemplateRef }) backContent: TemplateRef<ElementRef>;\n    @ContentChild('backBackground', { read: TemplateRef }) backBackground: TemplateRef<ElementRef>;\n\n    /**\n     *\n     */\n    @Output() loaded = new EventEmitter();\n\n    /**\n     * Width of the card\n     * @default `240px`\n     */\n    @Input() width:  CSSString = '240px';\n    /**\n     * Height of the card\n     * @default `320px`\n     */\n    @Input() height: CSSString = '320px';\n    /**\n     * Inset padding of the parallax\n     * @default 80\n     */\n    @Input() bgInset:  number = 80;\n    /**\n     * Duration for the flip animation in ms\n     * @default 1200\n     */\n    @Input() flipAnimationDuration:  number = 1200;\n\n    renderCardFront = true;\n    renderCardBack = true;\n    showBackOfCard = false;\n\n    private get wrapper() { return this.element.nativeElement as HTMLElement; }\n    private get cardFront() { return this.wrapper.querySelector('.card.front') as HTMLElement; }\n    private get cardBack() { return this.wrapper.querySelector('.card.backface') as HTMLElement; }\n    private get backgroundElement() { return this.cardFront.querySelector('.card-bg') as HTMLDivElement; }\n    private get backfaceBackgroundElement() { return this.cardBack.querySelector('.card-bg') as HTMLDivElement; }\n\n    private pointerX = 0;\n    private pointerY = 0;\n    private pointerLeave = 0;\n\n    constructor(\n        private readonly element: ElementRef,\n        private readonly ngZone: NgZone\n    ) { }\n\n    ngAfterViewInit() {\n        const el = this.wrapper;\n\n        this.ngZone.runOutsideAngular(() => {\n            // Directly attach events to the wrapper\n            el.onpointermove = (e) => this.onPointerMove(e);\n            el.onpointerenter = () => this.onPointerEnter();\n            el.onpointerleave = () => this.onPointerLeave();\n        })\n        el.onclick = () => this.onClick();\n\n        this.loaded.emit();\n    }\n\n    onPointerMove(e: PointerEvent) {\n        const { width, height, left, top } = this.wrapper.getBoundingClientRect();\n        this.pointerX = e.pageX - left - (width / 2);\n        this.pointerY = e.pageY - top - (height / 2);\n\n        this.render();\n    }\n\n    onPointerEnter() {\n        clearTimeout(this.pointerLeave);\n    }\n\n    onPointerLeave() {\n        this.pointerLeave = setTimeout(() => {\n            this.pointerX = 0;\n            this.pointerY = 0;\n            this.render();\n        }, 600) as any;\n    }\n\n    // TODO: This can get intercepted in some states\n    onClick() {\n        this.showBackOfCard = !this.showBackOfCard;\n        this.render()\n    }\n\n    render = () => {\n        const { width, height } = this.wrapper.getBoundingClientRect();\n        const mousePX = this.pointerX / width;\n        const mousePY = this.pointerY / height;\n\n        // Rotation factors\n        const rX = mousePX * this.bgInset / 1.75;\n        const rY = mousePY * -this.bgInset / 1.75;\n\n        // Translation factors\n        const tX = mousePX * -this.bgInset * 2;\n        const tY = mousePY * -this.bgInset * 2;\n\n        if (this.renderCardFront) {\n            this.backgroundElement.style.transform = `translateX(${tX}px) translateY(${tY}px)`;\n        }\n        if (this.renderCardBack) {\n            this.backfaceBackgroundElement.style.transform = `translateX(${tX}px) translateY(${tY}px)`;\n        }\n\n        if (this.showBackOfCard) {\n            this.cardFront.style.transform = `rotateY(180deg) rotateX(${-rY}deg)`;\n            this.cardBack.style.transform = `rotateY(${-rX}deg) rotateX(${-rY}deg)`;\n        }\n        else {\n            this.cardFront.style.transform = `rotateY(${rX}deg) rotateX(${rY}deg)`;\n            this.cardBack.style.transform = `rotateY(180deg) rotateX(${-rY}deg)`;\n        }\n    }\n}\n","@if (renderCardBack) {\n    <div class=\"card backface\">\n        <div class=\"card-bg\" style=\"transform: translateX(0) translateY(0)\">\n            <ng-template [ngTemplateOutlet]=\"backBackground\" />\n        </div>\n        <div class=\"card-content\">\n            <ng-template [ngTemplateOutlet]=\"backContent\" />\n        </div>\n    </div>\n}\n\n@if (renderCardFront) {\n    <div class=\"card front\">\n        <div class=\"card-bg\" style=\"transform: translateX(0) translateY(0)\">\n            <ng-template [ngTemplateOutlet]=\"background\" />\n        </div>\n        <div class=\"card-content\">\n            @if (content) {\n                <ng-template [ngTemplateOutlet]=\"content\"/>\n            }\n            @else {\n                <ng-content/>\n            }\n        </div>\n    </div>\n}\n\n\n"]}

package/esm2022/core/components/types.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const NGX_WEB_COMPONENTS_CONFIG = new InjectionToken('webcomponents-config');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vY29yZS9jb21wb25lbnRzL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFL0MsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQUcsSUFBSSxjQUFjLENBQXlCLHNCQUFzQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgY29uc3QgTkdYX1dFQl9DT01QT05FTlRTX0NPTkZJRyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxOZ3hXZWJDb21wb25lbnRzQ29uZmlnPignd2ViY29tcG9uZW50cy1jb25maWcnKTtcblxuZXhwb3J0IHR5cGUgTmd4V2ViQ29tcG9uZW50c0NvbmZpZyA9IFBhcnRpYWw8e1xuICAgIC8qKlxuICAgICAqIFRoZSBwYXRoIHRoYXQgYXNzZXRzIHdpbGwgdWx0aW1hdGVseSBiZSBzZXJ2ZWQgZnJvbS5cbiAgICAgKiBEZWZhdWx0IGAvYXNzZXRzL2BcbiAgICAgKi9cbiAgICBhc3NldFBhdGg6IHN0cmluZztcbn0+O1xuXG5cbiJdfQ==

package/esm2022/core/directives/image-cache.directive.mjs

@@ -0,0 +1,143 @@
+import { Directive, Inject, InjectionToken, Input, Optional } from '@angular/core';
+import { INDEXEDDB, createInstance } from 'localforage';
+import * as i0 from "@angular/core";
+const storage = createInstance({
+    name: "@dotglitch",
+    storeName: "image-cache",
+    driver: INDEXEDDB,
+    version: 1
+});
+const imageCache = {};
+const loadingSvg = `data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32px" height="32px" viewBox="0 0 100 100" preserveAspectRatio="xMidYMid"><circle cx="50" cy="50" fill="none" stroke="%2340c4ff" stroke-width="10" r="35" stroke-dasharray="164.93361431346415 56.97787143782138"><animateTransform attributeName="transform" type="rotate" repeatCount="indefinite" dur="1s" values="0 50 50;360 50 50" keyTimes="0;1"></animateTransform></circle><!-- [ldio] generated by https://loading.io/ --></svg>`;
+const brokenSvg = `data:image/svg+xml;utf8,<svg width="800" height="800" viewBox="0 0 24 24" version="1.1" xml:space="preserve" xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg"><line x1="10.08" y1="8.29" x2="10.18" y2="8.29" style="fill:none;stroke:#000000;stroke-width:2.5;stroke-linecap:round;stroke-linejoin:round" /><path d="m 10.51,14.8 5.2,5.2 H 20 a 1,1 0 0 0 1,-1 V 15.73 L 15.29,10 Z M 3,16.71 V 19 a 1,1 0 0 0 1,1 h 11.71 l -8,-8 z M 21,5 v 14 a 1,1 0 0 1 -1,1 H 4 A 1,1 0 0 1 3,19 V 5 A 1,1 0 0 1 4,4 h 16 a 1,1 0 0 1 1,1 z" style="fill:none;stroke:#000000;stroke-width:2;stroke-linecap:round;stroke-linejoin:round" /><path d="M 21.193388,21.193388 2.8066108,2.8066108 m 18.3867772,0 L 2.8066108,21.193388" style="stroke:%23ff0000;stroke-width:2.62668;stroke-linecap:round;stroke-linejoin:round;stroke-opacity:1" /></svg>`;
+export const NGX_IMAGE_CACHE_CONFIG = new InjectionToken('ngx-image-cache-config');
+export class NgxImageCacheDirective {
+    get el() { return this.element.nativeElement; }
+    constructor(element, cacheConfig) {
+        this.element = element;
+        this.cacheConfig = cacheConfig;
+    }
+    ngOnChanges() {
+        this.getCachedImage();
+    }
+    async getCachedImage() {
+        if (this.el.src?.trim() == this.url?.trim() || // Check that there's an actual change
+            this.url?.trim().length == 0 // Check that there's an actual URL
+        )
+            return;
+        // Check if it's in the memory cache
+        if (imageCache[this.url]) {
+            const image = imageCache[this.url];
+            // If the image is currently loading, show the loader
+            // and add it to the reflist
+            if (image['_loading'] == true) {
+                image['_refs'].push(this.el);
+                this.el.setAttribute("loading", "true");
+                this.el.src = this.cacheConfig?.loadingPlaceholder || loadingSvg;
+            }
+            else {
+                // The image is fully loaded, swap out the src with a data-uri
+                this.el.setAttribute("loading", "false");
+                this.el.src = image.src;
+            }
+            // If it's already in the image cache, we're going to trust that it loads properly.
+            return;
+        }
+        // Check if it's in indexedDB
+        if (this.configuration?.cacheInIndexedDB != false) {
+            const cached = await storage.getItem(this.url);
+            if (cached) {
+                // Attempt to load the base64 data from indexeddb.
+                // If this fails, we'll fall back to attempting to download the image
+                this.el.src = cached.data;
+                const evt = await new Promise(res => {
+                    this.el.addEventListener('load', res);
+                    this.el.addEventListener('error', res);
+                });
+                // If the event isn't an error
+                if (evt.type == "load") {
+                    this.el.setAttribute("loading", "false");
+                    if (this.configuration?.cacheInMemory != false) {
+                        // Successfully loaded into element
+                        // Create an entry in the memory cache
+                        const image = imageCache[this.url] = new Image();
+                        image.src = cached.data;
+                        image['_createdAt'] = Date.now();
+                    }
+                    return;
+                }
+                else {
+                    // Else, we try to load again.
+                    this.el.src = this.cacheConfig?.loadingPlaceholder || loadingSvg;
+                }
+            }
+        }
+        const image = (() => {
+            if (this.configuration?.cacheInMemory != false) {
+                return imageCache[this.url] = new Image();
+            }
+            return new Image();
+        })();
+        // const clone = image.cloneNode(true) as HTMLImageElement;
+        image['_refs'] = image['_refs'] ?? [];
+        image['_refs'].push(this.el);
+        image['_loading'] = true;
+        image['_createdAt'] = Date.now();
+        // Show a loader while the image downloads.
+        this.el.setAttribute("loading", "true");
+        this.el.src = this.cacheConfig?.loadingPlaceholder || loadingSvg;
+        // Fetch the image via JS and cache it as base64
+        window.fetch(this.url)
+            .then(response => response.blob())
+            .then(blob => new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onloadend = () => {
+                image.src = reader.result;
+                storage.setItem(this.url, {
+                    timestamp: Date.now(),
+                    data: reader.result
+                });
+                image['_refs'].forEach((ref) => {
+                    ref.src = image.src;
+                });
+                image['_loading'] = false;
+                resolve(0);
+            };
+            reader.onerror = reject;
+            reader.readAsDataURL(blob);
+        }))
+            .catch(err => {
+            // If a failure occurs, purge this entry from the cache
+            // TODO: Render better "broken" image
+            delete imageCache[this.url];
+            image['_refs'].forEach((ref) => {
+                ref.src = this.cacheConfig?.brokenPlaceholder || brokenSvg;
+                ref.setAttribute("loading", "failed");
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NgxImageCacheDirective, deps: [{ token: i0.ElementRef }, { token: NGX_IMAGE_CACHE_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: NgxImageCacheDirective, isStandalone: true, selector: "img[ngx-cache]", inputs: { url: ["source", "url"], configuration: ["ngx-cache-config", "configuration"] }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NgxImageCacheDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'img[ngx-cache]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [NGX_IMAGE_CACHE_CONFIG]
+                }] }], propDecorators: { url: [{
+                type: Input,
+                args: ["source"]
+            }, {
+                type: Input,
+                args: ["ngx-cache"]
+            }], configuration: [{
+                type: Input,
+                args: ["ngx-cache-config"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-cache.directive.js","sourceRoot":"","sources":["../../../../packages/common/core/directives/image-cache.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, Inject, InjectionToken, Input, Optional } from '@angular/core';\nimport { INDEXEDDB, createInstance } from 'localforage';\n\nconst storage = createInstance({\n    name: \"@dotglitch\",\n    storeName: \"image-cache\",\n    driver: INDEXEDDB,\n    version: 1\n});\n\n\nconst imageCache: {\n    [key: string]: HTMLImageElement;\n} = {};\n\nconst loadingSvg = `data:image/svg+xml;utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"32px\" height=\"32px\" viewBox=\"0 0 100 100\" preserveAspectRatio=\"xMidYMid\"><circle cx=\"50\" cy=\"50\" fill=\"none\" stroke=\"%2340c4ff\" stroke-width=\"10\" r=\"35\" stroke-dasharray=\"164.93361431346415 56.97787143782138\"><animateTransform attributeName=\"transform\" type=\"rotate\" repeatCount=\"indefinite\" dur=\"1s\" values=\"0 50 50;360 50 50\" keyTimes=\"0;1\"></animateTransform></circle><!-- [ldio] generated by https://loading.io/ --></svg>`;\nconst brokenSvg = `data:image/svg+xml;utf8,<svg width=\"800\" height=\"800\" viewBox=\"0 0 24 24\" version=\"1.1\" xml:space=\"preserve\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:svg=\"http://www.w3.org/2000/svg\"><line x1=\"10.08\" y1=\"8.29\" x2=\"10.18\" y2=\"8.29\" style=\"fill:none;stroke:#000000;stroke-width:2.5;stroke-linecap:round;stroke-linejoin:round\" /><path d=\"m 10.51,14.8 5.2,5.2 H 20 a 1,1 0 0 0 1,-1 V 15.73 L 15.29,10 Z M 3,16.71 V 19 a 1,1 0 0 0 1,1 h 11.71 l -8,-8 z M 21,5 v 14 a 1,1 0 0 1 -1,1 H 4 A 1,1 0 0 1 3,19 V 5 A 1,1 0 0 1 4,4 h 16 a 1,1 0 0 1 1,1 z\" style=\"fill:none;stroke:#000000;stroke-width:2;stroke-linecap:round;stroke-linejoin:round\" /><path d=\"M 21.193388,21.193388 2.8066108,2.8066108 m 18.3867772,0 L 2.8066108,21.193388\" style=\"stroke:%23ff0000;stroke-width:2.62668;stroke-linecap:round;stroke-linejoin:round;stroke-opacity:1\" /></svg>`;\n\nexport type NgxImageCacheConfig = {\n    /**\n     * Image to use as a placeholder while loading the main image\n     * Recommended to use inlined SVG or a base64 encoded image\n     */\n    loadingPlaceholder?: string,\n    /**\n     * Image to use as a placeholder where images fail to load\n     * Recommended to use inlined SVG or a base64 encoded image\n     */\n    brokenPlaceholder?: string\n}\n\nexport const NGX_IMAGE_CACHE_CONFIG = new InjectionToken<NgxImageCacheConfig>('ngx-image-cache-config');\n\n\nexport type NgxImageCacheConfiguration = {\n    /**\n     * Max age to cache an image in milliseconds.\n     * If set to `0` or a negative number, images will never expire.\n     */\n    maxAge: number,\n    /**\n     * Set to `false` to disable memory caching for the image\n     * If both `cacheInMemory` and `cacheInIndexedDB` are false,\n     * no caching will happen. (You'll still get the loader)\n     */\n    cacheInMemory: boolean,\n    /**\n     * Set to `false` to disable indexedDB caching for the image\n     * If both `cacheInMemory` and `cacheInIndexedDB` are false,\n     * no caching will happen. (You'll still get the loader)\n     */\n    cacheInIndexedDB: boolean\n}\n\n@Directive({\n    selector: 'img[ngx-cache]',\n    standalone: true\n})\nexport class NgxImageCacheDirective {\n\n    @Input(\"source\")\n    @Input(\"ngx-cache\") url: string;\n\n    @Input(\"ngx-cache-config\") configuration: NgxImageCacheConfiguration;\n\n    private get el() { return this.element.nativeElement as HTMLImageElement }\n\n    constructor(\n        private readonly element: ElementRef,\n        @Optional() @Inject(NGX_IMAGE_CACHE_CONFIG) private readonly cacheConfig: NgxImageCacheConfig\n    ) { }\n\n    ngOnChanges() {\n        this.getCachedImage();\n    }\n\n    async getCachedImage() {\n        if (\n            this.el.src?.trim() == this.url?.trim() || // Check that there's an actual change\n            this.url?.trim().length == 0 // Check that there's an actual URL\n        ) return;\n\n        // Check if it's in the memory cache\n        if (imageCache[this.url]) {\n            const image = imageCache[this.url];\n\n            // If the image is currently loading, show the loader\n            // and add it to the reflist\n            if (image['_loading'] == true) {\n                image['_refs'].push(this.el);\n\n                this.el.setAttribute(\"loading\", \"true\");\n                this.el.src = this.cacheConfig?.loadingPlaceholder || loadingSvg;\n            }\n            else {\n                // The image is fully loaded, swap out the src with a data-uri\n                this.el.setAttribute(\"loading\", \"false\");\n                this.el.src = image.src;\n            }\n\n            // If it's already in the image cache, we're going to trust that it loads properly.\n            return;\n        }\n\n        // Check if it's in indexedDB\n        if (this.configuration?.cacheInIndexedDB != false) {\n            const cached = await storage.getItem<any>(this.url);\n            if (cached) {\n                // Attempt to load the base64 data from indexeddb.\n                // If this fails, we'll fall back to attempting to download the image\n                this.el.src = cached.data;\n\n                const evt: Event = await new Promise(res => {\n                    this.el.addEventListener('load', res);\n                    this.el.addEventListener('error', res);\n                });\n\n                // If the event isn't an error\n                if (evt.type == \"load\") {\n                    this.el.setAttribute(\"loading\", \"false\");\n\n                    if (this.configuration?.cacheInMemory != false) {\n                        // Successfully loaded into element\n                        // Create an entry in the memory cache\n                        const image = imageCache[this.url] = new Image();\n                        image.src = cached.data;\n                        image['_createdAt'] = Date.now();\n                    }\n                    return;\n                }\n                else {\n                    // Else, we try to load again.\n                    this.el.src = this.cacheConfig?.loadingPlaceholder || loadingSvg;\n                }\n            }\n        }\n\n        const image = (() => {\n            if (this.configuration?.cacheInMemory != false) {\n                return imageCache[this.url] = new Image();\n            }\n            return new Image();\n        })();\n\n        // const clone = image.cloneNode(true) as HTMLImageElement;\n        image['_refs'] = image['_refs'] ?? [];\n        image['_refs'].push(this.el);\n        image['_loading'] = true;\n        image['_createdAt'] = Date.now();\n\n        // Show a loader while the image downloads.\n        this.el.setAttribute(\"loading\", \"true\");\n        this.el.src = this.cacheConfig?.loadingPlaceholder || loadingSvg;\n\n        // Fetch the image via JS and cache it as base64\n        window.fetch(this.url)\n            .then(response => response.blob())\n            .then(blob => new Promise((resolve, reject) => {\n                const reader = new FileReader();\n                reader.onloadend = () => {\n                    image.src = reader.result as string;\n\n                    storage.setItem(this.url, {\n                        timestamp: Date.now(),\n                        data: reader.result\n                    });\n\n                    image['_refs'].forEach((ref: HTMLImageElement) => {\n                        ref.src = image.src;\n                    });\n\n                    image['_loading'] = false;\n                    resolve(0);\n                };\n                reader.onerror = reject;\n                reader.readAsDataURL(blob);\n            }))\n            .catch(err => {\n                // If a failure occurs, purge this entry from the cache\n                // TODO: Render better \"broken\" image\n                delete imageCache[this.url];\n                image['_refs'].forEach((ref: HTMLImageElement) => {\n                    ref.src = this.cacheConfig?.brokenPlaceholder || brokenSvg;\n                    ref.setAttribute(\"loading\", \"failed\");\n                });\n            });\n    }\n}\n"]}