@agnos-ui/angular-headless 0.0.1-alpha.3 → 0.0.1-alpha.5

package/esm2022/slot.directive.mjs

@@ -0,0 +1,199 @@
+import { DOCUMENT } from '@angular/common';
+import { Directive, EnvironmentInjector, Input, TemplateRef, ViewContainerRef, createComponent, inject, reflectComponentType } from '@angular/core';
+import { ComponentTemplate } from './types';
+import * as i0 from "@angular/core";
+class SlotHandler {
+    constructor(viewContainerRef, document) {
+        this.viewContainerRef = viewContainerRef;
+        this.document = document;
+    }
+    slotChange(slot, props) { }
+    propsChange(slot, props) { }
+    destroy() { }
+}
+class StringSlotHandler extends SlotHandler {
+    #nodeRef;
+    #previousText = '';
+    slotChange(slot) {
+        if (slot === this.#previousText) {
+            return;
+        }
+        this.#previousText = slot;
+        if (this.#nodeRef) {
+            this.#nodeRef.textContent = slot;
+        }
+        else {
+            const viewContainerElement = this.viewContainerRef.element.nativeElement;
+            if (this.document && viewContainerElement?.parentNode) {
+                this.#nodeRef = viewContainerElement.parentNode.insertBefore(this.document.createTextNode(slot), viewContainerElement);
+            }
+        }
+    }
+    destroy() {
+        this.#nodeRef?.parentNode?.removeChild(this.#nodeRef);
+        this.#nodeRef = undefined;
+    }
+}
+class FunctionSlotHandler extends SlotHandler {
+    #stringSlotHandler = new StringSlotHandler(this.viewContainerRef, this.document);
+    slotChange(slot, props) {
+        this.#stringSlotHandler.slotChange(slot(props));
+    }
+    propsChange(slot, props) {
+        this.#stringSlotHandler.slotChange(slot(props));
+    }
+    destroy() {
+        this.#stringSlotHandler.destroy();
+    }
+}
+class ComponentSlotHandler extends SlotHandler {
+    #componentRef;
+    #properties;
+    slotChange(slot, props) {
+        if (this.#componentRef) {
+            this.destroy();
+        }
+        this.#componentRef = this.viewContainerRef.createComponent(slot);
+        this.#applyProperties(props);
+    }
+    #applyProperties(props, oldProperties) {
+        const properties = Object.keys(props);
+        this.#properties = properties;
+        const componentRef = this.#componentRef;
+        for (const property of properties) {
+            componentRef.setInput(property, props[property]);
+            oldProperties?.delete(property);
+        }
+    }
+    propsChange(slot, props) {
+        const oldProperties = new Set(this.#properties);
+        this.#applyProperties(props, oldProperties);
+        const componentRef = this.#componentRef;
+        for (const property of oldProperties) {
+            componentRef.setInput(property, undefined);
+        }
+    }
+    destroy() {
+        this.viewContainerRef.clear();
+        this.#componentRef = undefined;
+    }
+}
+class TemplateRefSlotHandler extends SlotHandler {
+    #viewRef;
+    #props;
+    slotChange(slot, props) {
+        if (this.#viewRef) {
+            this.destroy();
+        }
+        props = { ...props };
+        this.#props = props;
+        this.#viewRef = this.viewContainerRef.createEmbeddedView(slot, props);
+    }
+    propsChange(slot, props) {
+        if (this.#viewRef) {
+            const templateProps = this.#props;
+            const oldProperties = new Set(Object.keys(templateProps));
+            for (const property of Object.keys(props)) {
+                templateProps[property] = props[property];
+                oldProperties.delete(property);
+            }
+            for (const oldProperty of oldProperties) {
+                delete templateProps[oldProperty];
+            }
+            this.#viewRef.markForCheck();
+        }
+    }
+    destroy() {
+        this.viewContainerRef.clear();
+    }
+}
+class ComponentTemplateSlotHandler extends SlotHandler {
+    #componentRef;
+    #templateSlotHandler = new TemplateRefSlotHandler(this.viewContainerRef, this.document);
+    #templateRef;
+    slotChange(slot, props) {
+        if (this.#componentRef) {
+            this.destroy();
+        }
+        this.#componentRef = createComponent(slot.component, {
+            elementInjector: this.viewContainerRef.injector,
+            environmentInjector: this.viewContainerRef.injector.get(EnvironmentInjector),
+        });
+        this.#templateRef = this.#componentRef.instance[slot.templateProp];
+        this.#templateSlotHandler.slotChange(this.#templateRef, props);
+    }
+    propsChange(slot, props) {
+        this.#templateSlotHandler.propsChange(this.#templateRef, props);
+    }
+    destroy() {
+        this.#templateSlotHandler.destroy();
+        this.#componentRef?.destroy();
+        this.#componentRef = undefined;
+    }
+}
+const getSlotType = (value) => {
+    if (!value)
+        return undefined;
+    const type = typeof value;
+    switch (type) {
+        case 'string':
+            return StringSlotHandler;
+        case 'function':
+            if (reflectComponentType(value)) {
+                return ComponentSlotHandler;
+            }
+            return FunctionSlotHandler;
+        case 'object':
+            if (value instanceof TemplateRef) {
+                return TemplateRefSlotHandler;
+            }
+            if (value instanceof ComponentTemplate) {
+                return ComponentTemplateSlotHandler;
+            }
+            break;
+    }
+    return undefined;
+};
+export class SlotDirective {
+    constructor() {
+        this._viewContainerRef = inject(ViewContainerRef);
+        this._document = inject(DOCUMENT);
+    }
+    ngOnChanges(changes) {
+        const slotChange = changes['slot'];
+        const propsChange = changes['props'];
+        const slot = this.slot;
+        if (slotChange) {
+            const newSlotType = getSlotType(slot);
+            if (newSlotType !== this._slotType) {
+                this._slotHandler?.destroy();
+                this._slotHandler = newSlotType ? new newSlotType(this._viewContainerRef, this._document) : undefined;
+                this._slotType = newSlotType;
+            }
+            this._slotHandler?.slotChange(slot, this.props);
+        }
+        else if (propsChange) {
+            this._slotHandler?.propsChange(slot, this.props);
+        }
+    }
+    ngOnDestroy() {
+        this._slotHandler?.destroy();
+        this._slotHandler = undefined;
+    }
+    static { this.ɵfac = function SlotDirective_Factory(t) { return new (t || SlotDirective)(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: SlotDirective, selectors: [["", "auSlot", ""]], inputs: { slot: ["auSlot", "slot"], props: ["auSlotProps", "props"] }, standalone: true, features: [i0.ɵɵNgOnChangesFeature] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SlotDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[auSlot]',
+                standalone: true,
+            }]
+    }], null, { slot: [{
+            type: Input,
+            args: ['auSlot']
+        }], props: [{
+            type: Input,
+            args: ['auSlotProps']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slot.directive.js","sourceRoot":"","sources":["../../src/slot.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {DOCUMENT} from '@angular/common';\nimport type {ComponentRef, EmbeddedViewRef, OnChanges, OnDestroy, SimpleChanges, Type} from '@angular/core';\nimport {Directive, EnvironmentInjector, Input, TemplateRef, ViewContainerRef, createComponent, inject, reflectComponentType} from '@angular/core';\nimport type {SlotContent} from './types';\nimport {ComponentTemplate} from './types';\n\nabstract class SlotHandler<Props extends Record<string, any>, Slot extends SlotContent<Props> = SlotContent<Props>> {\n\tconstructor(\n\t\tpublic viewContainerRef: ViewContainerRef,\n\t\tpublic document: Document,\n\t) {}\n\tslotChange(slot: Slot, props: Props) {}\n\tpropsChange(slot: Slot, props: Props) {}\n\tdestroy() {}\n}\n\nclass StringSlotHandler<Props extends Record<string, any>> extends SlotHandler<Props, string> {\n\t#nodeRef: Text | undefined;\n\t#previousText = '';\n\n\toverride slotChange(slot: string): void {\n\t\tif (slot === this.#previousText) {\n\t\t\treturn;\n\t\t}\n\t\tthis.#previousText = slot;\n\t\tif (this.#nodeRef) {\n\t\t\tthis.#nodeRef.textContent = slot;\n\t\t} else {\n\t\t\tconst viewContainerElement: Comment | undefined = this.viewContainerRef.element.nativeElement;\n\t\t\tif (this.document && viewContainerElement?.parentNode) {\n\t\t\t\tthis.#nodeRef = viewContainerElement.parentNode.insertBefore(this.document.createTextNode(slot), viewContainerElement);\n\t\t\t}\n\t\t}\n\t}\n\n\toverride destroy(): void {\n\t\tthis.#nodeRef?.parentNode?.removeChild(this.#nodeRef);\n\t\tthis.#nodeRef = undefined;\n\t}\n}\n\nclass FunctionSlotHandler<Props extends Record<string, any>> extends SlotHandler<Props, (props: Props) => string> {\n\t#stringSlotHandler = new StringSlotHandler(this.viewContainerRef, this.document);\n\n\toverride slotChange(slot: (props: Props) => string, props: Props): void {\n\t\tthis.#stringSlotHandler.slotChange(slot(props));\n\t}\n\n\toverride propsChange(slot: (props: Props) => string, props: Props): void {\n\t\tthis.#stringSlotHandler.slotChange(slot(props));\n\t}\n\n\toverride destroy(): void {\n\t\tthis.#stringSlotHandler.destroy();\n\t}\n}\n\nclass ComponentSlotHandler<Props extends Record<string, any>> extends SlotHandler<Props, Type<unknown>> {\n\t#componentRef: ComponentRef<any> | undefined;\n\t#properties: string[];\n\n\toverride slotChange(slot: Type<unknown>, props: Props): void {\n\t\tif (this.#componentRef) {\n\t\t\tthis.destroy();\n\t\t}\n\t\tthis.#componentRef = this.viewContainerRef.createComponent(slot);\n\t\tthis.#applyProperties(props);\n\t}\n\n\t#applyProperties(props: Props, oldProperties?: Set<string>) {\n\t\tconst properties = Object.keys(props);\n\t\tthis.#properties = properties;\n\t\tconst componentRef = this.#componentRef!;\n\t\tfor (const property of properties) {\n\t\t\tcomponentRef.setInput(property, props[property]);\n\t\t\toldProperties?.delete(property);\n\t\t}\n\t}\n\n\toverride propsChange(slot: Type<unknown>, props: Props): void {\n\t\tconst oldProperties = new Set(this.#properties);\n\t\tthis.#applyProperties(props, oldProperties);\n\t\tconst componentRef = this.#componentRef!;\n\t\tfor (const property of oldProperties) {\n\t\t\tcomponentRef.setInput(property, undefined);\n\t\t}\n\t}\n\n\toverride destroy(): void {\n\t\tthis.viewContainerRef.clear();\n\t\tthis.#componentRef = undefined;\n\t}\n}\n\nclass TemplateRefSlotHandler<Props extends Record<string, any>> extends SlotHandler<Props, TemplateRef<Props>> {\n\t#viewRef: EmbeddedViewRef<Props> | undefined;\n\t#props: Props;\n\n\toverride slotChange(slot: TemplateRef<Props>, props: Props): void {\n\t\tif (this.#viewRef) {\n\t\t\tthis.destroy();\n\t\t}\n\t\tprops = {...props};\n\t\tthis.#props = props;\n\t\tthis.#viewRef = this.viewContainerRef.createEmbeddedView(slot, props);\n\t}\n\n\toverride propsChange(slot: TemplateRef<Props>, props: Props): void {\n\t\tif (this.#viewRef) {\n\t\t\tconst templateProps = this.#props;\n\t\t\tconst oldProperties = new Set<keyof Props>(Object.keys(templateProps));\n\t\t\tfor (const property of Object.keys(props) as (keyof Props)[]) {\n\t\t\t\ttemplateProps[property] = props[property];\n\t\t\t\toldProperties.delete(property);\n\t\t\t}\n\t\t\tfor (const oldProperty of oldProperties) {\n\t\t\t\tdelete templateProps[oldProperty];\n\t\t\t}\n\t\t\tthis.#viewRef.markForCheck();\n\t\t}\n\t}\n\n\toverride destroy(): void {\n\t\tthis.viewContainerRef.clear();\n\t}\n}\n\nclass ComponentTemplateSlotHandler<\n\tProps extends Record<string, any>,\n\tK extends string,\n\tT extends {[key in K]: TemplateRef<Props>},\n> extends SlotHandler<Props, ComponentTemplate<Props, K, T>> {\n\t#componentRef: ComponentRef<T> | undefined;\n\t#templateSlotHandler = new TemplateRefSlotHandler(this.viewContainerRef, this.document);\n\t#templateRef: TemplateRef<Props> | undefined;\n\n\toverride slotChange(slot: ComponentTemplate<Props, K, T>, props: Props): void {\n\t\tif (this.#componentRef) {\n\t\t\tthis.destroy();\n\t\t}\n\t\tthis.#componentRef = createComponent(slot.component, {\n\t\t\telementInjector: this.viewContainerRef.injector,\n\t\t\tenvironmentInjector: this.viewContainerRef.injector.get(EnvironmentInjector),\n\t\t});\n\t\tthis.#templateRef = this.#componentRef.instance[slot.templateProp];\n\t\tthis.#templateSlotHandler.slotChange(this.#templateRef, props);\n\t}\n\n\toverride propsChange(slot: ComponentTemplate<Props, K, T>, props: Props): void {\n\t\tthis.#templateSlotHandler.propsChange(this.#templateRef!, props);\n\t}\n\n\toverride destroy(): void {\n\t\tthis.#templateSlotHandler.destroy();\n\t\tthis.#componentRef?.destroy();\n\t\tthis.#componentRef = undefined;\n\t}\n}\n\nconst getSlotType = (value: any): undefined | {new (viewContainerRef: ViewContainerRef, document: Document): SlotHandler<any>} => {\n\tif (!value) return undefined;\n\tconst type = typeof value;\n\tswitch (type) {\n\t\tcase 'string':\n\t\t\treturn StringSlotHandler;\n\t\tcase 'function':\n\t\t\tif (reflectComponentType(value)) {\n\t\t\t\treturn ComponentSlotHandler;\n\t\t\t}\n\t\t\treturn FunctionSlotHandler;\n\t\tcase 'object':\n\t\t\tif (value instanceof TemplateRef) {\n\t\t\t\treturn TemplateRefSlotHandler;\n\t\t\t}\n\t\t\tif (value instanceof ComponentTemplate) {\n\t\t\t\treturn ComponentTemplateSlotHandler;\n\t\t\t}\n\t\t\tbreak;\n\t}\n\treturn undefined;\n};\n\n@Directive({\n\tselector: '[auSlot]',\n\tstandalone: true,\n})\nexport class SlotDirective<Props extends Record<string, any>> implements OnChanges, OnDestroy {\n\t@Input('auSlot') slot: SlotContent<Props>;\n\t@Input('auSlotProps') props: Props;\n\n\tprivate _viewContainerRef = inject(ViewContainerRef);\n\tprivate _document = inject(DOCUMENT);\n\tprivate _slotType: ReturnType<typeof getSlotType>;\n\tprivate _slotHandler: SlotHandler<Props> | undefined;\n\n\tngOnChanges(changes: SimpleChanges): void {\n\t\tconst slotChange = changes['slot'];\n\t\tconst propsChange = changes['props'];\n\t\tconst slot = this.slot;\n\t\tif (slotChange) {\n\t\t\tconst newSlotType = getSlotType(slot);\n\t\t\tif (newSlotType !== this._slotType) {\n\t\t\t\tthis._slotHandler?.destroy();\n\t\t\t\tthis._slotHandler = newSlotType ? new newSlotType(this._viewContainerRef, this._document) : undefined;\n\t\t\t\tthis._slotType = newSlotType;\n\t\t\t}\n\t\t\tthis._slotHandler?.slotChange(slot, this.props);\n\t\t} else if (propsChange) {\n\t\t\tthis._slotHandler?.propsChange(slot, this.props);\n\t\t}\n\t}\n\n\tngOnDestroy(): void {\n\t\tthis._slotHandler?.destroy();\n\t\tthis._slotHandler = undefined;\n\t}\n}\n"]}

package/esm2022/slotDefault.directive.mjs

@@ -0,0 +1,20 @@
+import { Directive, Input, TemplateRef, inject } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SlotDefaultDirective {
+    constructor() {
+        this.templateRef = inject((TemplateRef));
+    }
+    ngOnInit() {
+        this.auSlotDefault.update((value) => ({ ...value, slotDefault: this.templateRef }));
+    }
+    static { this.ɵfac = function SlotDefaultDirective_Factory(t) { return new (t || SlotDefaultDirective)(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: SlotDefaultDirective, selectors: [["", "auSlotDefault", ""]], inputs: { auSlotDefault: "auSlotDefault" }, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SlotDefaultDirective, [{
+        type: Directive,
+        args: [{ selector: '[auSlotDefault]', standalone: true }]
+    }], null, { auSlotDefault: [{
+            type: Input,
+            args: ['auSlotDefault']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xvdERlZmF1bHQuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Nsb3REZWZhdWx0LmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUMsU0FBUyxFQUFFLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxFQUFDLE1BQU0sZUFBZSxDQUFDOztBQUlwRSxNQUFNLE9BQU8sb0JBQW9CO0lBRGpDO1FBSUMsZ0JBQVcsR0FBRyxNQUFNLENBQUMsQ0FBQSxXQUFjLENBQUEsQ0FBQyxDQUFDO0tBS3JDO0lBSEEsUUFBUTtRQUNQLElBQUksQ0FBQyxhQUFhLENBQUMsTUFBTSxDQUFDLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEVBQUMsR0FBRyxLQUFLLEVBQUUsV0FBVyxFQUFFLElBQUksQ0FBQyxXQUFXLEVBQUMsQ0FBQyxDQUFDLENBQUM7SUFDbkYsQ0FBQztxRkFQVyxvQkFBb0I7b0VBQXBCLG9CQUFvQjs7aUZBQXBCLG9CQUFvQjtjQURoQyxTQUFTO2VBQUMsRUFBQyxRQUFRLEVBQUUsaUJBQWlCLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBQztnQkFFakMsYUFBYTtrQkFBcEMsS0FBSzttQkFBQyxlQUFlIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUge1dyaXRhYmxlU2lnbmFsfSBmcm9tICdAYW1hZGV1cy1pdC1ncm91cC90YW5zdSc7XG5pbXBvcnQgdHlwZSB7T25Jbml0fSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7RGlyZWN0aXZlLCBJbnB1dCwgVGVtcGxhdGVSZWYsIGluamVjdH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgdHlwZSB7U2xvdENvbnRlbnR9IGZyb20gJy4vdHlwZXMnO1xuXG5ARGlyZWN0aXZlKHtzZWxlY3RvcjogJ1thdVNsb3REZWZhdWx0XScsIHN0YW5kYWxvbmU6IHRydWV9KVxuZXhwb3J0IGNsYXNzIFNsb3REZWZhdWx0RGlyZWN0aXZlPFQgZXh0ZW5kcyBvYmplY3Q+IGltcGxlbWVudHMgT25Jbml0IHtcblx0QElucHV0KCdhdVNsb3REZWZhdWx0JykgYXVTbG90RGVmYXVsdDogV3JpdGFibGVTaWduYWw8e3Nsb3REZWZhdWx0PzogU2xvdENvbnRlbnQ8VD59PjtcblxuXHR0ZW1wbGF0ZVJlZiA9IGluamVjdChUZW1wbGF0ZVJlZjxUPik7XG5cblx0bmdPbkluaXQoKTogdm9pZCB7XG5cdFx0dGhpcy5hdVNsb3REZWZhdWx0LnVwZGF0ZSgodmFsdWUpID0+ICh7Li4udmFsdWUsIHNsb3REZWZhdWx0OiB0aGlzLnRlbXBsYXRlUmVmfSkpO1xuXHR9XG59XG4iXX0=

package/esm2022/types.mjs

@@ -0,0 +1,21 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export * from '@agnos-ui/core/types';
+export class ComponentTemplate {
+    constructor(component, templateProp) {
+        this.component = component;
+        this.templateProp = templateProp;
+    }
+}
+export class SlotComponent {
+    static { this.ɵfac = function SlotComponent_Factory(t) { return new (t || SlotComponent)(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: SlotComponent, inputs: { state: "state", widget: "widget" } }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SlotComponent, [{
+        type: Directive
+    }], null, { state: [{
+            type: Input
+        }], widget: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/coercion.mjs

@@ -0,0 +1,34 @@
+import { booleanAttribute, numberAttribute } from '@angular/core';
+/**
+ * Transforms a value (typically a string) to a boolean.
+ * Intended to be used as a transform function of an input.
+ *
+ *  @usageNotes
+ *  ```typescript
+ *  @Input({ transform: auBooleanAttribute }) status: boolean | undefined;
+ *  ```
+ * @param value Value to be transformed.
+ */
+export function auBooleanAttribute(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return booleanAttribute(value);
+}
+/**
+ * Transforms a value (typically a string) to a number.
+ * Intended to be used as a transform function of an input.
+ * @param value Value to be transformed.
+ *
+ *  @usageNotes
+ *  ```typescript
+ *  @Input({ transform: auNumberAttribute }) id: number | undefined;
+ *  ```
+ */
+export function auNumberAttribute(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return numberAttribute(value);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29lcmNpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvY29lcmNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLGdCQUFnQixFQUFFLGVBQWUsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUVoRTs7Ozs7Ozs7O0dBU0c7QUFDSCxNQUFNLFVBQVUsa0JBQWtCLENBQUMsS0FBYztJQUNoRCxJQUFJLEtBQUssS0FBSyxTQUFTLEVBQUU7UUFDeEIsT0FBTyxTQUFTLENBQUM7S0FDakI7SUFDRCxPQUFPLGdCQUFnQixDQUFDLEtBQUssQ0FBQyxDQUFDO0FBQ2hDLENBQUM7QUFFRDs7Ozs7Ozs7O0dBU0c7QUFDSCxNQUFNLFVBQVUsaUJBQWlCLENBQUMsS0FBYztJQUMvQyxJQUFJLEtBQUssS0FBSyxTQUFTLEVBQUU7UUFDeEIsT0FBTyxTQUFTLENBQUM7S0FDakI7SUFDRCxPQUFPLGVBQWUsQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUMvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtib29sZWFuQXR0cmlidXRlLCBudW1iZXJBdHRyaWJ1dGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIFRyYW5zZm9ybXMgYSB2YWx1ZSAodHlwaWNhbGx5IGEgc3RyaW5nKSB0byBhIGJvb2xlYW4uXG4gKiBJbnRlbmRlZCB0byBiZSB1c2VkIGFzIGEgdHJhbnNmb3JtIGZ1bmN0aW9uIG9mIGFuIGlucHV0LlxuICpcbiAqICBAdXNhZ2VOb3Rlc1xuICogIGBgYHR5cGVzY3JpcHRcbiAqICBASW5wdXQoeyB0cmFuc2Zvcm06IGF1Qm9vbGVhbkF0dHJpYnV0ZSB9KSBzdGF0dXM6IGJvb2xlYW4gfCB1bmRlZmluZWQ7XG4gKiAgYGBgXG4gKiBAcGFyYW0gdmFsdWUgVmFsdWUgdG8gYmUgdHJhbnNmb3JtZWQuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBhdUJvb2xlYW5BdHRyaWJ1dGUodmFsdWU6IHVua25vd24pOiBib29sZWFuIHwgdW5kZWZpbmVkIHtcblx0aWYgKHZhbHVlID09PSB1bmRlZmluZWQpIHtcblx0XHRyZXR1cm4gdW5kZWZpbmVkO1xuXHR9XG5cdHJldHVybiBib29sZWFuQXR0cmlidXRlKHZhbHVlKTtcbn1cblxuLyoqXG4gKiBUcmFuc2Zvcm1zIGEgdmFsdWUgKHR5cGljYWxseSBhIHN0cmluZykgdG8gYSBudW1iZXIuXG4gKiBJbnRlbmRlZCB0byBiZSB1c2VkIGFzIGEgdHJhbnNmb3JtIGZ1bmN0aW9uIG9mIGFuIGlucHV0LlxuICogQHBhcmFtIHZhbHVlIFZhbHVlIHRvIGJlIHRyYW5zZm9ybWVkLlxuICpcbiAqICBAdXNhZ2VOb3Rlc1xuICogIGBgYHR5cGVzY3JpcHRcbiAqICBASW5wdXQoeyB0cmFuc2Zvcm06IGF1TnVtYmVyQXR0cmlidXRlIH0pIGlkOiBudW1iZXIgfCB1bmRlZmluZWQ7XG4gKiAgYGBgXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBhdU51bWJlckF0dHJpYnV0ZSh2YWx1ZTogdW5rbm93bik6IG51bWJlciB8IHVuZGVmaW5lZCB7XG5cdGlmICh2YWx1ZSA9PT0gdW5kZWZpbmVkKSB7XG5cdFx0cmV0dXJuIHVuZGVmaW5lZDtcblx0fVxuXHRyZXR1cm4gbnVtYmVyQXR0cmlidXRlKHZhbHVlKTtcbn1cbiJdfQ==

package/esm2022/utils/directive.mjs

@@ -0,0 +1,63 @@
+import { DestroyRef, Directive, ElementRef, Input, inject } from '@angular/core';
+import * as i0 from "@angular/core";
+export * from '@agnos-ui/core/utils/directive';
+// All calls of the directive in this class are done asynchronously (with await 0)
+// in order to avoid ExpressionChangedAfterItHasBeenCheckedError
+// or the corresponding issue with signals (https://github.com/angular/angular/issues/50320)
+// This is relevant especially if calling the directive changes variables used in a template.
+export const useDirectiveForHost = (use, params) => {
+    const ref = inject(ElementRef);
+    let instance = use?.(ref.nativeElement, params);
+    async function destroyDirectiveInstance() {
+        const oldInstance = instance;
+        instance = undefined;
+        use = undefined;
+        if (oldInstance?.destroy) {
+            await 0;
+            oldInstance.destroy?.();
+        }
+    }
+    inject(DestroyRef).onDestroy(destroyDirectiveInstance);
+    async function update(newUse, newParams) {
+        if (newUse !== use) {
+            destroyDirectiveInstance();
+            use = newUse;
+            params = newParams;
+            if (newUse) {
+                await 0;
+                // checks that the directive did not change while waiting:
+                if (use === newUse && !instance) {
+                    instance = use(ref.nativeElement, params);
+                }
+            }
+        }
+        else if (newParams != params) {
+            params = newParams;
+            await 0;
+            instance?.update?.(params);
+        }
+    }
+    return { update };
+};
+export class UseDirective {
+    #useDirective = useDirectiveForHost();
+    ngOnChanges() {
+        this.#useDirective.update(this.use, this.params);
+    }
+    static { this.ɵfac = function UseDirective_Factory(t) { return new (t || UseDirective)(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: UseDirective, selectors: [["", "auUse", ""]], inputs: { use: ["auUse", "use"], params: ["auUseParams", "params"] }, standalone: true, features: [i0.ɵɵNgOnChangesFeature] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(UseDirective, [{
+        type: Directive,
+        args: [{
+                standalone: true,
+                selector: '[auUse]',
+            }]
+    }], null, { use: [{
+            type: Input,
+            args: ['auUse']
+        }], params: [{
+            type: Input,
+            args: ['auUseParams']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/stores.mjs

@@ -0,0 +1,14 @@
+import { DestroyRef, inject, signal } from '@angular/core';
+import { ZoneWrapper } from './zone';
+export * from '@agnos-ui/core/utils/stores';
+export const toAngularSignal = (tansuSignal) => {
+    const zoneWrapper = inject(ZoneWrapper);
+    const res = signal(undefined);
+    const subscription = zoneWrapper.outsideNgZone(tansuSignal.subscribe)((value) => {
+        res.set(value);
+        zoneWrapper.planNgZoneRun();
+    });
+    inject(DestroyRef).onDestroy(zoneWrapper.outsideNgZone(subscription));
+    return res;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxzL3N0b3Jlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUMsVUFBVSxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDekQsT0FBTyxFQUFDLFdBQVcsRUFBQyxNQUFNLFFBQVEsQ0FBQztBQUVuQyxjQUFjLDZCQUE2QixDQUFDO0FBRTVDLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxDQUFJLFdBQThCLEVBQWEsRUFBRTtJQUMvRSxNQUFNLFdBQVcsR0FBRyxNQUFNLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDeEMsTUFBTSxHQUFHLEdBQUcsTUFBTSxDQUFDLFNBQXFCLENBQUMsQ0FBQztJQUMxQyxNQUFNLFlBQVksR0FBRyxXQUFXLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFO1FBQy9FLEdBQUcsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDZixXQUFXLENBQUMsYUFBYSxFQUFFLENBQUM7SUFDN0IsQ0FBQyxDQUFDLENBQUM7SUFDSCxNQUFNLENBQUMsVUFBVSxDQUFDLENBQUMsU0FBUyxDQUFDLFdBQVcsQ0FBQyxhQUFhLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQztJQUN0RSxPQUFPLEdBQUcsQ0FBQztBQUNaLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHtSZWFkYWJsZVNpZ25hbH0gZnJvbSAnQGFtYWRldXMtaXQtZ3JvdXAvdGFuc3UnO1xuaW1wb3J0IHR5cGUge1NpZ25hbH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0Rlc3Ryb3lSZWYsIGluamVjdCwgc2lnbmFsfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7Wm9uZVdyYXBwZXJ9IGZyb20gJy4vem9uZSc7XG5cbmV4cG9ydCAqIGZyb20gJ0BhZ25vcy11aS9jb3JlL3V0aWxzL3N0b3Jlcyc7XG5cbmV4cG9ydCBjb25zdCB0b0FuZ3VsYXJTaWduYWwgPSA8VD4odGFuc3VTaWduYWw6IFJlYWRhYmxlU2lnbmFsPFQ+KTogU2lnbmFsPFQ+ID0+IHtcblx0Y29uc3Qgem9uZVdyYXBwZXIgPSBpbmplY3QoWm9uZVdyYXBwZXIpO1xuXHRjb25zdCByZXMgPSBzaWduYWwodW5kZWZpbmVkIGFzIGFueSBhcyBUKTtcblx0Y29uc3Qgc3Vic2NyaXB0aW9uID0gem9uZVdyYXBwZXIub3V0c2lkZU5nWm9uZSh0YW5zdVNpZ25hbC5zdWJzY3JpYmUpKCh2YWx1ZSkgPT4ge1xuXHRcdHJlcy5zZXQodmFsdWUpO1xuXHRcdHpvbmVXcmFwcGVyLnBsYW5OZ1pvbmVSdW4oKTtcblx0fSk7XG5cdGluamVjdChEZXN0cm95UmVmKS5vbkRlc3Ryb3koem9uZVdyYXBwZXIub3V0c2lkZU5nWm9uZShzdWJzY3JpcHRpb24pKTtcblx0cmV0dXJuIHJlcztcbn07XG4iXX0=

package/esm2022/utils/widget.mjs

@@ -0,0 +1,114 @@
+import { computed, writable } from '@amadeus-it-group/tansu';
+import { Directive, Injector, inject, runInInjectionContext } from '@angular/core';
+import { toSlotContextWidget, } from '../types';
+import { toAngularSignal, toReadableStore } from './stores';
+import { ZoneWrapper } from './zone';
+import * as i0 from "@angular/core";
+const createPatchSlots = (set) => {
+    let lastValue = {};
+    return (object) => {
+        const newValue = {};
+        let hasChange = false;
+        for (const key of Object.keys(object)) {
+            const objectKey = object[key];
+            if (objectKey != null) {
+                // only use defined slots
+                newValue[key] = objectKey;
+            }
+            if (objectKey != lastValue[key]) {
+                hasChange = true;
+            }
+        }
+        if (hasChange) {
+            lastValue = newValue;
+            set(newValue);
+        }
+    };
+};
+export const callWidgetFactoryWithConfig = ({ factory, defaultConfig, widgetConfig, events, afterInit, }) => {
+    const injector = inject(Injector);
+    const slots$ = writable({});
+    const props = {};
+    let initDone;
+    const res = {
+        initialized: new Promise((resolve) => {
+            initDone = resolve;
+        }),
+        patchSlots: createPatchSlots(slots$.set),
+        patch(newProps) {
+            // temporary function replaced in ngInit
+            Object.assign(props, newProps);
+        },
+        ngInit() {
+            runInInjectionContext(injector, () => {
+                const zoneWrapper = inject(ZoneWrapper);
+                factory = zoneWrapper.outsideNgZone(factory);
+                const defaultConfig$ = toReadableStore(defaultConfig);
+                events = zoneWrapper.insideNgZoneWrapFunctionsObject(events);
+                const widget = factory({
+                    config: computed(() => ({ ...defaultConfig$(), ...widgetConfig?.(), ...slots$(), ...events })),
+                    props,
+                });
+                const wrappedWidget = {
+                    ...widget,
+                    patch: zoneWrapper.outsideNgZone(widget.patch),
+                    directives: zoneWrapper.outsideNgZoneWrapDirectivesObject(widget.directives),
+                    actions: zoneWrapper.outsideNgZoneWrapFunctionsObject(widget.actions),
+                    api: zoneWrapper.outsideNgZoneWrapFunctionsObject(widget.api),
+                };
+                Object.assign(res, wrappedWidget, {
+                    widget: toSlotContextWidget(wrappedWidget),
+                    ngState: toAngularSignal(wrappedWidget.state$),
+                });
+                afterInit?.();
+                initDone();
+            });
+        },
+    };
+    return res;
+};
+function patchSimpleChanges(patchFn, changes) {
+    const obj = {};
+    for (const [key, simpleChange] of Object.entries(changes)) {
+        if (simpleChange !== undefined) {
+            obj[key] = simpleChange.currentValue;
+        }
+    }
+    patchFn(obj);
+}
+/**
+ * Stores the result of the first call to the getter and returns that result directly for subsequent calls
+ *
+ * Applies to: class getters
+ */
+export const CachedProperty = (target, property, descriptor) => {
+    const originalGet = descriptor.get;
+    descriptor.get = function () {
+        const value = originalGet?.call(this);
+        Object.defineProperty(this, property, { value, writable: false });
+        return value;
+    };
+};
+export class BaseWidgetDirective {
+    get api() {
+        return this._widget.api;
+    }
+    get state() {
+        return this._widget.ngState;
+    }
+    get widget() {
+        return this._widget.widget;
+    }
+    ngOnChanges(changes) {
+        patchSimpleChanges(this._widget.patch, changes);
+    }
+    ngOnInit() {
+        this._widget.ngInit();
+    }
+    static { this.ɵfac = function BaseWidgetDirective_Factory(t) { return new (t || BaseWidgetDirective)(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: BaseWidgetDirective, features: [i0.ɵɵNgOnChangesFeature] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BaseWidgetDirective, [{
+        type: Directive
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget.js","sourceRoot":"","sources":["../../../src/utils/widget.ts"],"names":[],"mappings":"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","sourcesContent":["import {computed, writable, type ReadableSignal} from '@amadeus-it-group/tansu';\nimport type {OnChanges, OnInit, Signal, SimpleChanges} from '@angular/core';\nimport {Directive, Injector, inject, runInInjectionContext} from '@angular/core';\nimport {\n\ttoSlotContextWidget,\n\ttype AngularWidget,\n\ttype ContextWidget,\n\ttype Widget,\n\ttype WidgetFactory,\n\ttype WidgetProps,\n\ttype WidgetState,\n} from '../types';\nimport {toAngularSignal, toReadableStore} from './stores';\nimport {ZoneWrapper} from './zone';\n\nconst createPatchSlots = <T extends object>(set: (object: Partial<T>) => void) => {\n\tlet lastValue: Partial<T> = {};\n\treturn (object: T) => {\n\t\tconst newValue: Partial<T> = {};\n\t\tlet hasChange = false;\n\t\tfor (const key of Object.keys(object) as (string & keyof T)[]) {\n\t\t\tconst objectKey = (object as any)[key];\n\t\t\tif (objectKey != null) {\n\t\t\t\t// only use defined slots\n\t\t\t\tnewValue[key] = objectKey;\n\t\t\t}\n\t\t\tif (objectKey != lastValue[key]) {\n\t\t\t\thasChange = true;\n\t\t\t}\n\t\t}\n\t\tif (hasChange) {\n\t\t\tlastValue = newValue;\n\t\t\tset(newValue);\n\t\t}\n\t};\n};\n\nexport const callWidgetFactoryWithConfig = <W extends Widget>({\n\tfactory,\n\tdefaultConfig,\n\twidgetConfig,\n\tevents,\n\tafterInit,\n}: {\n\tfactory: WidgetFactory<W>;\n\tdefaultConfig?: Partial<WidgetProps<W>> | ReadableSignal<Partial<WidgetProps<W>> | undefined>;\n\twidgetConfig?: null | undefined | ReadableSignal<Partial<WidgetProps<W>> | undefined>;\n\tevents: Pick<WidgetProps<W>, keyof WidgetProps<W> & `on${string}`>;\n\tafterInit?: () => void;\n}): AngularWidget<W> => {\n\tconst injector = inject(Injector);\n\tconst slots$ = writable({});\n\tconst props = {};\n\tlet initDone: () => void;\n\tconst res = {\n\t\tinitialized: new Promise((resolve) => {\n\t\t\tinitDone = resolve;\n\t\t}),\n\t\tpatchSlots: createPatchSlots(slots$.set),\n\t\tpatch(newProps) {\n\t\t\t// temporary function replaced in ngInit\n\t\t\tObject.assign(props, newProps);\n\t\t},\n\t\tngInit() {\n\t\t\trunInInjectionContext(injector, () => {\n\t\t\t\tconst zoneWrapper = inject(ZoneWrapper);\n\t\t\t\tfactory = zoneWrapper.outsideNgZone(factory);\n\t\t\t\tconst defaultConfig$ = toReadableStore(defaultConfig);\n\t\t\t\tevents = zoneWrapper.insideNgZoneWrapFunctionsObject(events);\n\t\t\t\tconst widget = factory({\n\t\t\t\t\tconfig: computed(() => ({...defaultConfig$(), ...widgetConfig?.(), ...slots$(), ...(events as Partial<WidgetProps<W>>)})),\n\t\t\t\t\tprops,\n\t\t\t\t});\n\t\t\t\tconst wrappedWidget: W = {\n\t\t\t\t\t...widget,\n\t\t\t\t\tpatch: zoneWrapper.outsideNgZone(widget.patch),\n\t\t\t\t\tdirectives: zoneWrapper.outsideNgZoneWrapDirectivesObject(widget.directives),\n\t\t\t\t\tactions: zoneWrapper.outsideNgZoneWrapFunctionsObject(widget.actions),\n\t\t\t\t\tapi: zoneWrapper.outsideNgZoneWrapFunctionsObject(widget.api),\n\t\t\t\t};\n\t\t\t\tObject.assign(res, wrappedWidget, {\n\t\t\t\t\twidget: toSlotContextWidget(wrappedWidget),\n\t\t\t\t\tngState: toAngularSignal(wrappedWidget.state$ as ReadableSignal<WidgetState<W>>),\n\t\t\t\t});\n\t\t\t\tafterInit?.();\n\t\t\t\tinitDone();\n\t\t\t});\n\t\t},\n\t} as AngularWidget<W>;\n\n\treturn res;\n};\n\nfunction patchSimpleChanges(patchFn: (obj: any) => void, changes: SimpleChanges) {\n\tconst obj: any = {};\n\tfor (const [key, simpleChange] of Object.entries(changes)) {\n\t\tif (simpleChange !== undefined) {\n\t\t\tobj[key] = simpleChange.currentValue;\n\t\t}\n\t}\n\tpatchFn(obj);\n}\n\n/**\n * Stores the result of the first call to the getter and returns that result directly for subsequent calls\n *\n * Applies to: class getters\n */\nexport const CachedProperty = (target: any, property: PropertyKey, descriptor: PropertyDescriptor) => {\n\tconst originalGet = descriptor.get;\n\tdescriptor.get = function (this: any) {\n\t\tconst value = originalGet?.call(this);\n\t\tObject.defineProperty(this, property, {value, writable: false});\n\t\treturn value;\n\t};\n};\n\n@Directive()\nexport abstract class BaseWidgetDirective<W extends Widget> implements OnChanges, OnInit {\n\tprotected abstract readonly _widget: AngularWidget<W>;\n\n\tget api(): W['api'] {\n\t\treturn this._widget.api;\n\t}\n\n\tget state(): Signal<WidgetState<W>> {\n\t\treturn this._widget.ngState;\n\t}\n\n\tget widget(): ContextWidget<W> {\n\t\treturn this._widget.widget;\n\t}\n\n\tngOnChanges(changes: SimpleChanges): void {\n\t\tpatchSimpleChanges(this._widget.patch, changes);\n\t}\n\n\tngOnInit(): void {\n\t\tthis._widget.ngInit();\n\t}\n}\n"]}

package/esm2022/utils/zone.mjs

@@ -0,0 +1,67 @@
+import { Injectable, NgZone, inject } from '@angular/core';
+import * as i0 from "@angular/core";
+const noop = () => { };
+const identity = (a) => a;
+const createObjectWrapper = (wrap) => (object) => {
+    if (!object || typeof object !== 'object') {
+        return object;
+    }
+    const res = {};
+    for (const key of Object.keys(object)) {
+        res[key] = wrap(object[key]);
+    }
+    return res;
+};
+const createReturnValueWrapper = (wrapReturnValue, wrapResult) => (fn) => wrapResult(typeof fn === 'function' ? ((...args) => wrapReturnValue(fn(...args))) : fn);
+export class ZoneWrapper {
+    constructor() {
+        this.#zone = inject(NgZone);
+        this.#hasZone = this.#zone.run(() => NgZone.isInAngularZone()); // check if zone is enabled (can be NoopZone, cf https://angular.io/guide/zone#noopzone)
+        this.#runNeeded = false;
+        this.#runPlanned = false;
+        this.planNgZoneRun = this.#hasZone
+            ? () => {
+                if (this.#zone.isStable) {
+                    this.#runNeeded = true;
+                    if (!this.#runPlanned) {
+                        this.#runPlanned = true;
+                        (async () => {
+                            await 0;
+                            this.#runPlanned = false;
+                            if (this.#runNeeded) {
+                                this.ngZoneRun(noop);
+                            }
+                        })();
+                    }
+                }
+            }
+            : noop;
+        this.insideNgZone = this.#hasZone
+            ? (fn) => (typeof fn === 'function' ? ((...args) => this.ngZoneRun(() => fn(...args))) : fn)
+            : identity;
+        this.insideNgZoneWrapFunctionsObject = createObjectWrapper(this.insideNgZone);
+        this.outsideNgZone = this.#hasZone
+            ? (fn) => (typeof fn === 'function' ? ((...args) => this.#zone.runOutsideAngular(() => fn(...args))) : fn)
+            : identity;
+        this.outsideNgZoneWrapFunctionsObject = createObjectWrapper(this.outsideNgZone);
+        this.outsideNgZoneWrapDirective = createReturnValueWrapper(this.outsideNgZoneWrapFunctionsObject, this.outsideNgZone);
+        this.outsideNgZoneWrapDirectivesObject = createObjectWrapper(this.outsideNgZoneWrapDirective);
+    }
+    #zone;
+    #hasZone; // check if zone is enabled (can be NoopZone, cf https://angular.io/guide/zone#noopzone)
+    #runNeeded;
+    #runPlanned;
+    ngZoneRun(fn) {
+        this.#runNeeded = false;
+        return this.#zone.run(fn);
+    }
+    static { this.ɵfac = function ZoneWrapper_Factory(t) { return new (t || ZoneWrapper)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ZoneWrapper, factory: ZoneWrapper.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ZoneWrapper, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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