@scania-nl/tegel-angular-extensions 0.0.7 → 0.0.9

package/esm2022/lib/modal/directives/dynamic-component.directive.mjs

@@ -0,0 +1,135 @@
+import { DestroyRef, Directive, effect, inject, input, untracked, ViewContainerRef, } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Dynamically renders an Angular component and wires its signal inputs/outputs.
+ *
+ * This directive:
+ * - Creates/destroys the component when the type changes.
+ * - Applies inputs via `setInput`.
+ * - Subscribes to outputs and forwards emitted values to handlers.
+ * - Cleans subscriptions and the component instance on destroy.
+ *
+ * @example
+ * ```html
+ * <ng-container
+ *   taeDynamicComponent
+ *   [component]="MyComponent"
+ *   [inputs]="{ name: 'John', age: 25 }"
+ *   [outputs]="{ submitted: (data) => handleSubmit(data) }"
+ * />
+ * ```
+ */
+export class DynamicComponentDirective {
+    component = input.required();
+    inputs = input();
+    outputs = input();
+    viewContainer = inject(ViewContainerRef);
+    destroyRef = inject(DestroyRef);
+    // Current component instance reference managed by this directive.
+    componentRef;
+    outputSubscriptions = new Set();
+    constructor() {
+        // Recreate the component whenever the type changes.
+        effect(() => {
+            const componentType = this.component();
+            untracked(() => {
+                this.destroyComponent();
+                this.createComponent(componentType);
+            });
+        });
+        // Apply new inputs whenever the `inputs` signal changes.
+        effect(() => {
+            const inputsValue = this.inputs();
+            if (inputsValue && this.componentRef) {
+                untracked(() => this.applyInputs(inputsValue));
+            }
+        });
+        // Ensure cleanup if the host view is destroyed.
+        this.destroyRef.onDestroy(() => this.destroyComponent());
+    }
+    /**
+     * Creates the component and wires initial inputs/outputs.
+     * @param componentType Component type to instantiate.
+     */
+    createComponent(componentType) {
+        this.viewContainer.clear();
+        this.componentRef = this.viewContainer.createComponent(componentType);
+        const inputsValue = this.inputs();
+        if (inputsValue) {
+            this.applyInputs(inputsValue);
+        }
+        const outputsValue = this.outputs();
+        if (outputsValue) {
+            this.subscribeToOutputs(outputsValue);
+        }
+        this.componentRef.changeDetectorRef.detectChanges();
+    }
+    /**
+     * Applies input values to the component instance using `setInput`.
+     * @param inputs Input values keyed by input name.
+     */
+    applyInputs(inputs) {
+        if (!this.componentRef)
+            return;
+        Object.entries(inputs).forEach(([key, value]) => {
+            this.componentRef?.setInput(key, value);
+        });
+        this.componentRef.changeDetectorRef.markForCheck();
+    }
+    /**
+     * Subscribes to output signal emitters and forwards values to handlers.
+     * @param outputs Output handler map keyed by output name.
+     */
+    subscribeToOutputs(outputs) {
+        if (!this.componentRef)
+            return;
+        // Clear previous subscriptions before wiring new outputs.
+        this.clearOutputSubscriptions();
+        const instance = this.componentRef.instance;
+        Object.entries(outputs).forEach(([key, handler]) => {
+            if (typeof handler !== 'function')
+                return;
+            const output = instance[key];
+            // Subscribe to the output signal emitter if present.
+            if (this.isOutputEmitterRef(output)) {
+                const subscription = output.subscribe((value) => handler(value));
+                this.outputSubscriptions.add(subscription);
+            }
+        });
+    }
+    /**
+     * Clears all output subscriptions.
+     */
+    clearOutputSubscriptions() {
+        this.outputSubscriptions.forEach((sub) => sub.unsubscribe());
+        this.outputSubscriptions.clear();
+    }
+    /**
+     * Destroys the dynamic component and cleans subscriptions.
+     */
+    destroyComponent() {
+        this.clearOutputSubscriptions();
+        this.componentRef?.destroy();
+        this.componentRef = undefined;
+    }
+    /**
+     * Type guard for Angular signal output emitters.
+     * @param value Value to test.
+     */
+    isOutputEmitterRef(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            'subscribe' in value &&
+            typeof value['subscribe'] === 'function');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: DynamicComponentDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.17", type: DynamicComponentDirective, isStandalone: true, selector: "[taeDynamicComponent]", inputs: { component: { classPropertyName: "component", publicName: "component", isSignal: true, isRequired: true, transformFunction: null }, inputs: { classPropertyName: "inputs", publicName: "inputs", isSignal: true, isRequired: false, transformFunction: null }, outputs: { classPropertyName: "outputs", publicName: "outputs", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: DynamicComponentDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[taeDynamicComponent]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-component.directive.js","sourceRoot":"","sources":["../../../../../../../libs/tegel-angular-extensions/src/lib/modal/directives/dynamic-component.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ComponentRef,\n  DestroyRef,\n  Directive,\n  effect,\n  inject,\n  input,\n  OutputEmitterRef,\n  OutputRefSubscription,\n  Type,\n  untracked,\n  ViewContainerRef,\n} from '@angular/core';\nimport {\n  ComponentInputs,\n  ComponentOutputs,\n} from '../../utils/angular-component-io';\n\n/**\n * Dynamically renders an Angular component and wires its signal inputs/outputs.\n *\n * This directive:\n * - Creates/destroys the component when the type changes.\n * - Applies inputs via `setInput`.\n * - Subscribes to outputs and forwards emitted values to handlers.\n * - Cleans subscriptions and the component instance on destroy.\n *\n * @example\n * ```html\n * <ng-container\n *   taeDynamicComponent\n *   [component]=\"MyComponent\"\n *   [inputs]=\"{ name: 'John', age: 25 }\"\n *   [outputs]=\"{ submitted: (data) => handleSubmit(data) }\"\n * />\n * ```\n */\n@Directive({\n  selector: '[taeDynamicComponent]',\n  standalone: true,\n})\nexport class DynamicComponentDirective<T> {\n  readonly component = input.required<Type<T>>();\n  readonly inputs = input<ComponentInputs<T>>();\n  readonly outputs = input<ComponentOutputs<T>>();\n\n  private readonly viewContainer = inject(ViewContainerRef);\n  private readonly destroyRef = inject(DestroyRef);\n\n  // Current component instance reference managed by this directive.\n  private componentRef?: ComponentRef<T>;\n  private readonly outputSubscriptions = new Set<OutputRefSubscription>();\n\n  constructor() {\n    // Recreate the component whenever the type changes.\n    effect(() => {\n      const componentType = this.component();\n\n      untracked(() => {\n        this.destroyComponent();\n        this.createComponent(componentType);\n      });\n    });\n\n    // Apply new inputs whenever the `inputs` signal changes.\n    effect(() => {\n      const inputsValue = this.inputs();\n\n      if (inputsValue && this.componentRef) {\n        untracked(() => this.applyInputs(inputsValue));\n      }\n    });\n\n    // Ensure cleanup if the host view is destroyed.\n    this.destroyRef.onDestroy(() => this.destroyComponent());\n  }\n\n  /**\n   * Creates the component and wires initial inputs/outputs.\n   * @param componentType Component type to instantiate.\n   */\n  private createComponent(componentType: Type<T>): void {\n    this.viewContainer.clear();\n    this.componentRef = this.viewContainer.createComponent(componentType);\n\n    const inputsValue = this.inputs();\n    if (inputsValue) {\n      this.applyInputs(inputsValue);\n    }\n\n    const outputsValue = this.outputs();\n    if (outputsValue) {\n      this.subscribeToOutputs(outputsValue);\n    }\n\n    this.componentRef.changeDetectorRef.detectChanges();\n  }\n\n  /**\n   * Applies input values to the component instance using `setInput`.\n   * @param inputs Input values keyed by input name.\n   */\n  private applyInputs(inputs: ComponentInputs<T>): void {\n    if (!this.componentRef) return;\n\n    Object.entries(inputs).forEach(([key, value]) => {\n      this.componentRef?.setInput(key, value);\n    });\n\n    this.componentRef.changeDetectorRef.markForCheck();\n  }\n\n  /**\n   * Subscribes to output signal emitters and forwards values to handlers.\n   * @param outputs Output handler map keyed by output name.\n   */\n  private subscribeToOutputs(outputs: ComponentOutputs<T>): void {\n    if (!this.componentRef) return;\n\n    // Clear previous subscriptions before wiring new outputs.\n    this.clearOutputSubscriptions();\n\n    const instance = this.componentRef.instance as Record<string, unknown>;\n\n    Object.entries(outputs).forEach(([key, handler]) => {\n      if (typeof handler !== 'function') return;\n\n      const output = instance[key];\n\n      // Subscribe to the output signal emitter if present.\n      if (this.isOutputEmitterRef(output)) {\n        const subscription = output.subscribe((value: unknown) =>\n          handler(value),\n        );\n        this.outputSubscriptions.add(subscription);\n      }\n    });\n  }\n\n  /**\n   * Clears all output subscriptions.\n   */\n  private clearOutputSubscriptions(): void {\n    this.outputSubscriptions.forEach((sub) => sub.unsubscribe());\n    this.outputSubscriptions.clear();\n  }\n\n  /**\n   * Destroys the dynamic component and cleans subscriptions.\n   */\n  private destroyComponent(): void {\n    this.clearOutputSubscriptions();\n    this.componentRef?.destroy();\n    this.componentRef = undefined;\n  }\n\n  /**\n   * Type guard for Angular signal output emitters.\n   * @param value Value to test.\n   */\n  private isOutputEmitterRef(\n    value: unknown,\n  ): value is OutputEmitterRef<unknown> {\n    return (\n      typeof value === 'object' &&\n      value !== null &&\n      'subscribe' in value &&\n      typeof (value as Record<string, unknown>)['subscribe'] === 'function'\n    );\n  }\n}\n"]}

package/esm2022/lib/modal/modal.service.mjs

@@ -0,0 +1,156 @@
+import { Injectable, inject, signal } from '@angular/core';
+import { MODAL_CONFIG } from './schema/modal.config';
+import * as i0 from "@angular/core";
+/**
+ * Central registry and lifecycle manager for modal instances.
+ *
+ * This service creates modals, tracks their state, and coordinates
+ * open/close/remove behavior across the application.
+ */
+export class ModalService {
+    /** Default modal configuration injected via `MODAL_CONFIG`. */
+    config = inject(MODAL_CONFIG);
+    /** Incrementing counter for modal id generation. */
+    id = 0;
+    /** Internal store of modals keyed by id. */
+    _modals = signal(new Map());
+    /** Read-only signal of all registered modals. */
+    modals = this._modals.asReadonly();
+    /**
+     * Creates a new modal instance and registers it.
+     * @param options Modal options used to initialize the instance.
+     * @returns A ModalRef for controlling the instance.
+     */
+    create(options = {}) {
+        // Create a new id and build the initial modal state.
+        const id = `modal-${++this.id}`;
+        const modal = this.buildModal(id, undefined, options);
+        // Persist to the internal store.
+        this.upsertModal(modal);
+        return {
+            id,
+            open: this.open.bind(this, id),
+            close: this.close.bind(this, id),
+            remove: this.remove.bind(this, id),
+        };
+    }
+    /**
+     * Opens a modal by id.
+     * @param id Modal id.
+     */
+    open(id) {
+        // Set open state to true if needed.
+        this.updateModalState(id, true);
+    }
+    /**
+     * Closes a modal by id.
+     * @param id Modal id.
+     */
+    close(id) {
+        const existing = this.getModal(id);
+        if (!existing?.isOpen)
+            return;
+        // Set open state to false and notify callbacks.
+        this.updateModalState(id, false);
+        existing.onClosed?.();
+        console.log('Modal closed:', id);
+        // Optionally remove the modal after closing.
+        if (existing.removeOnClose) {
+            this.remove(id);
+        }
+    }
+    /**
+     * Removes a modal from the registry and DOM.
+     * Closes the modal first if it is open.
+     * @param id Modal id.
+     */
+    remove(id) {
+        const existing = this.getModal(id);
+        if (!existing)
+            return;
+        // Remove from the internal store.
+        this._modals.update((modals) => {
+            const next = new Map(modals);
+            next.delete(id);
+            return next;
+        });
+        // Fire callbacks for cleanup.
+        if (existing.isOpen) {
+            existing.onClosed?.();
+        }
+        existing.onRemoved?.();
+        console.log('Modal removed:', id);
+    }
+    /**
+     * Closes all open modals.
+     */
+    closeAll() {
+        // Use service close to ensure removeOnClose behavior is honored.
+        this.modals().forEach((modal) => this.close(modal.id));
+    }
+    /**
+     * Removes all modals from the registry.
+     */
+    removeAll() {
+        // Use service remove to ensure callbacks are fired.
+        this.modals().forEach((modal) => this.remove(modal.id));
+    }
+    /**
+     * Looks up a modal by id.
+     * @param id Modal id.
+     */
+    getModal(id) {
+        return this._modals().get(id);
+    }
+    /**
+     * Updates the open/closed state of a modal if it exists.
+     * @param id Modal id.
+     * @param isOpen Desired open state.
+     */
+    updateModalState(id, isOpen) {
+        const existing = this.getModal(id);
+        if (!existing || existing.isOpen === isOpen)
+            return;
+        // Rebuild the modal with the new open state.
+        const updated = this.buildModal(id, existing, {}, isOpen);
+        this.upsertModal(updated);
+    }
+    /**
+     * Inserts or replaces a modal in the internal store.
+     * @param modal Modal to upsert.
+     */
+    upsertModal(modal) {
+        this._modals.update((modals) => new Map(modals).set(modal.id, modal));
+    }
+    /**
+     * Builds a modal instance by merging defaults, existing state, and options.
+     * @param id Modal id.
+     * @param existing Existing modal state (if any).
+     * @param options New options to apply.
+     * @param isOpen Optional override for open state.
+     */
+    buildModal(id, existing, options, isOpen) {
+        // Resolve initial open state from the override, options, existing state, or config.
+        const resolvedIsOpen = isOpen ??
+            options.startOpen ??
+            existing?.startOpen ??
+            this.config.startOpen;
+        // Merge config defaults, existing values, and new options.
+        return {
+            ...this.config,
+            ...existing,
+            ...options,
+            id,
+            isOpen: resolvedIsOpen,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: ModalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: ModalService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: ModalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal.service.js","sourceRoot":"","sources":["../../../../../../libs/tegel-angular-extensions/src/lib/modal/modal.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject, signal } from '@angular/core';\nimport { ModalRef } from './schema/modal-ref';\nimport { MODAL_CONFIG, ModalConfig } from './schema/modal.config';\nimport { Modal, ModalOptions } from './schema/modal.model';\n\n/**\n * Central registry and lifecycle manager for modal instances.\n *\n * This service creates modals, tracks their state, and coordinates\n * open/close/remove behavior across the application.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class ModalService {\n  /** Default modal configuration injected via `MODAL_CONFIG`. */\n  private readonly config = inject<ModalConfig>(MODAL_CONFIG);\n\n  /** Incrementing counter for modal id generation. */\n  private id = 0;\n  /** Internal store of modals keyed by id. */\n  private readonly _modals = signal<Map<string, Modal>>(new Map());\n\n  /** Read-only signal of all registered modals. */\n  readonly modals = this._modals.asReadonly();\n\n  /**\n   * Creates a new modal instance and registers it.\n   * @param options Modal options used to initialize the instance.\n   * @returns A ModalRef for controlling the instance.\n   */\n  create<T>(options: ModalOptions<T> = {}): ModalRef {\n    // Create a new id and build the initial modal state.\n    const id = `modal-${++this.id}`;\n    const modal = this.buildModal(id, undefined, options);\n    // Persist to the internal store.\n    this.upsertModal(modal);\n\n    return {\n      id,\n      open: this.open.bind(this, id),\n      close: this.close.bind(this, id),\n      remove: this.remove.bind(this, id),\n    } satisfies ModalRef;\n  }\n\n  /**\n   * Opens a modal by id.\n   * @param id Modal id.\n   */\n  open(id: string): void {\n    // Set open state to true if needed.\n    this.updateModalState(id, true);\n  }\n\n  /**\n   * Closes a modal by id.\n   * @param id Modal id.\n   */\n  close(id: string): void {\n    const existing = this.getModal(id);\n    if (!existing?.isOpen) return;\n\n    // Set open state to false and notify callbacks.\n    this.updateModalState(id, false);\n    existing.onClosed?.();\n    console.log('Modal closed:', id);\n\n    // Optionally remove the modal after closing.\n    if (existing.removeOnClose) {\n      this.remove(id);\n    }\n  }\n\n  /**\n   * Removes a modal from the registry and DOM.\n   * Closes the modal first if it is open.\n   * @param id Modal id.\n   */\n  remove(id: string): void {\n    const existing = this.getModal(id);\n    if (!existing) return;\n\n    // Remove from the internal store.\n    this._modals.update((modals) => {\n      const next = new Map(modals);\n      next.delete(id);\n      return next;\n    });\n\n    // Fire callbacks for cleanup.\n    if (existing.isOpen) {\n      existing.onClosed?.();\n    }\n    existing.onRemoved?.();\n    console.log('Modal removed:', id);\n  }\n\n  /**\n   * Closes all open modals.\n   */\n  closeAll(): void {\n    // Use service close to ensure removeOnClose behavior is honored.\n    this.modals().forEach((modal) => this.close(modal.id));\n  }\n\n  /**\n   * Removes all modals from the registry.\n   */\n  removeAll(): void {\n    // Use service remove to ensure callbacks are fired.\n    this.modals().forEach((modal) => this.remove(modal.id));\n  }\n\n  /**\n   * Looks up a modal by id.\n   * @param id Modal id.\n   */\n  private getModal(id: string): Modal | undefined {\n    return this._modals().get(id);\n  }\n\n  /**\n   * Updates the open/closed state of a modal if it exists.\n   * @param id Modal id.\n   * @param isOpen Desired open state.\n   */\n  private updateModalState(id: string, isOpen: boolean): void {\n    const existing = this.getModal(id);\n    if (!existing || existing.isOpen === isOpen) return;\n\n    // Rebuild the modal with the new open state.\n    const updated = this.buildModal(id, existing, {}, isOpen);\n    this.upsertModal(updated);\n  }\n\n  /**\n   * Inserts or replaces a modal in the internal store.\n   * @param modal Modal to upsert.\n   */\n  private upsertModal(modal: Modal): void {\n    this._modals.update((modals) => new Map(modals).set(modal.id, modal));\n  }\n\n  /**\n   * Builds a modal instance by merging defaults, existing state, and options.\n   * @param id Modal id.\n   * @param existing Existing modal state (if any).\n   * @param options New options to apply.\n   * @param isOpen Optional override for open state.\n   */\n  private buildModal(\n    id: string,\n    existing: Modal | undefined,\n    options: ModalOptions,\n    isOpen?: boolean,\n  ): Modal {\n    // Resolve initial open state from the override, options, existing state, or config.\n    const resolvedIsOpen =\n      isOpen ??\n      options.startOpen ??\n      existing?.startOpen ??\n      this.config.startOpen;\n\n    // Merge config defaults, existing values, and new options.\n    return {\n      ...this.config,\n      ...existing,\n      ...options,\n      id,\n      isOpen: resolvedIsOpen,\n    };\n  }\n}\n"]}

package/esm2022/lib/modal/provide-modal.mjs

@@ -0,0 +1,25 @@
+import { makeEnvironmentProviders, provideAppInitializer, } from '@angular/core';
+import { bootstrapGlobalComponent } from '../utils/bootstrap-global-component';
+import { ModalHostComponent } from './components/modal-host/modal-host.component';
+import { DEFAULT_MODAL_CONFIG, MODAL_CONFIG, } from './schema/modal.config';
+/**
+ * Provides modal configuration defaults and bootstraps the global modal host.
+ *
+ * @param config Optional config overrides applied on top of defaults.
+ * @returns EnvironmentProviders to register in application providers.
+ */
+export function provideModal(config = {}) {
+    return makeEnvironmentProviders([
+        {
+            provide: MODAL_CONFIG,
+            useFactory: () => ({
+                ...DEFAULT_MODAL_CONFIG,
+                ...(config ?? {}),
+            }),
+        },
+        provideAppInitializer(() => {
+            bootstrapGlobalComponent(ModalHostComponent, { reuseIfExists: true });
+        }),
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modal/schema/modal-ref.mjs

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

package/esm2022/lib/modal/schema/modal.config.mjs

@@ -0,0 +1,15 @@
+import { InjectionToken } from '@angular/core';
+/** Injection token for modal configuration defaults. */
+export const MODAL_CONFIG = new InjectionToken('ModalConfig');
+/** Default modal configuration. */
+export const DEFAULT_MODAL_CONFIG = {
+    size: 'md',
+    actionsPosition: 'static',
+    prevent: false,
+    closable: true,
+    alertDialog: 'dialog',
+    lazy: false,
+    startOpen: true,
+    removeOnClose: true,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modal/schema/modal.model.mjs

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

package/esm2022/lib/modal/schema/modal.types.mjs

@@ -0,0 +1,3 @@
+/** Pure domain/UI types for modal components. */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwudHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3RlZ2VsLWFuZ3VsYXItZXh0ZW5zaW9ucy9zcmMvbGliL21vZGFsL3NjaGVtYS9tb2RhbC50eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxpREFBaUQiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogUHVyZSBkb21haW4vVUkgdHlwZXMgZm9yIG1vZGFsIGNvbXBvbmVudHMuICovXG5cbi8qKiBTdXBwb3J0ZWQgbW9kYWwgc2l6ZXMuICovXG5leHBvcnQgdHlwZSBNb2RhbFNpemUgPSAnbGcnIHwgJ21kJyB8ICdzbScgfCAneHMnO1xuLyoqIFBvc2l0aW9uaW5nIGJlaGF2aW9yIGZvciB0aGUgYWN0aW9ucyBzbG90LiAqL1xuZXhwb3J0IHR5cGUgTW9kYWxBY3Rpb25zUG9zaXRpb24gPSAnc3RpY2t5JyB8ICdzdGF0aWMnO1xuLyoqIEFSSUEgcm9sZSB1c2VkIGJ5IHRoZSBtb2RhbCBmb3IgYWNjZXNzaWJpbGl0eS4gKi9cbmV4cG9ydCB0eXBlIE1vZGFsQWxlcnREaWFsb2dSb2xlID0gJ2RpYWxvZycgfCAnYWxlcnRkaWFsb2cnO1xuXG4vKiogRGVzY3JpcHRvciBmb3IgYSBidXR0b24gcmVuZGVyZWQgaW4gdGhlIG1vZGFsIGFjdGlvbnMgYXJlYS4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgTW9kYWxCdXR0b24ge1xuICAvKiogQnV0dG9uIGxhYmVsIHRleHQuICovXG4gIHRleHQ6IHN0cmluZztcbiAgLyoqIFZpc3VhbCB2YXJpYW50IGZvciB0aGUgYnV0dG9uLiAqL1xuICB2YXJpYW50PzogJ3ByaW1hcnknIHwgJ3NlY29uZGFyeScgfCAnc3VjY2VzcycgfCAnZGFuZ2VyJztcbiAgLyoqIFNpemUgb2YgdGhlIGJ1dHRvbi4gKi9cbiAgc2l6ZT86ICd4cycgfCAnc20nIHwgJ21kJyB8ICdsZyc7XG4gIC8qKiBXaGV0aGVyIHRoZSBidXR0b24gaXMgZGlzYWJsZWQuICovXG4gIGRpc2FibGVkPzogYm9vbGVhbjtcbiAgLyoqIElmIHRydWUsIGNsaWNraW5nIHRyaWdnZXJzIG1vZGFsIGRpc21pc3NhbC4gKi9cbiAgZGlzbWlzcz86IGJvb2xlYW47XG4gIC8qKiBPcHRpb25hbCBjbGljayBoYW5kbGVyIChzeW5jIG9yIGFzeW5jKS4gKi9cbiAgb25DbGljaz86ICgpID0+IHZvaWQgfCBQcm9taXNlPHZvaWQ+O1xufVxuIl19

package/esm2022/lib/toast/provide-toast.mjs

@@ -2,6 +2,12 @@ import { makeEnvironmentProviders, provideAppInitializer, } from '@angular/core'
 import { bootstrapGlobalComponent } from '../utils/bootstrap-global-component';
 import { ToastComponent } from './toast.component';
 import { DEFAULT_TOAST_CONFIG, TOAST_CONFIG, } from './toast.config';
+/**
+ * Provides toast configuration defaults and bootstraps the global toast host.
+ *
+ * @param config Optional config overrides applied on top of defaults.
+ * @returns EnvironmentProviders to register in application providers.
+ */
 export function provideToast(config = {}) {
     return makeEnvironmentProviders([
         {
@@ -16,4 +22,4 @@ export function provideToast(config = {}) {
         }),
     ]);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZS10b2FzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvdGVnZWwtYW5ndWxhci1leHRlbnNpb25zL3NyYy9saWIvdG9hc3QvcHJvdmlkZS10b2FzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBRUwsd0JBQXdCLEVBQ3hCLHFCQUFxQixHQUN0QixNQUFNLGVBQWUsQ0FBQztBQUN2QixPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUMvRSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDbkQsT0FBTyxFQUNMLG9CQUFvQixFQUNwQixZQUFZLEdBRWIsTUFBTSxnQkFBZ0IsQ0FBQztBQUV4QixNQUFNLFVBQVUsWUFBWSxDQUMxQixTQUErQixFQUFFO0lBRWpDLE9BQU8sd0JBQXdCLENBQUM7UUFDOUI7WUFDRSxPQUFPLEVBQUUsWUFBWTtZQUNyQixVQUFVLEVBQUUsR0FBRyxFQUFFLENBQUMsQ0FBQztnQkFDakIsR0FBRyxvQkFBb0I7Z0JBQ3ZCLEdBQUcsQ0FBQyxNQUFNLElBQUksRUFBRSxDQUFDO2FBQ2xCLENBQUM7U0FDSDtRQUNELHFCQUFxQixDQUFDLEdBQUcsRUFBRTtZQUN6Qix3QkFBd0IsQ0FBQyxjQUFjLEVBQUUsRUFBRSxhQUFhLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUNwRSxDQUFDLENBQUM7S0FDSCxDQUFDLENBQUM7QUFDTCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgRW52aXJvbm1lbnRQcm92aWRlcnMsXG4gIG1ha2VFbnZpcm9ubWVudFByb3ZpZGVycyxcbiAgcHJvdmlkZUFwcEluaXRpYWxpemVyLFxufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IGJvb3RzdHJhcEdsb2JhbENvbXBvbmVudCB9IGZyb20gJy4uL3V0aWxzL2Jvb3RzdHJhcC1nbG9iYWwtY29tcG9uZW50JztcbmltcG9ydCB7IFRvYXN0Q29tcG9uZW50IH0gZnJvbSAnLi90b2FzdC5jb21wb25lbnQnO1xuaW1wb3J0IHtcbiAgREVGQVVMVF9UT0FTVF9DT05GSUcsXG4gIFRPQVNUX0NPTkZJRyxcbiAgVG9hc3RDb25maWcsXG59IGZyb20gJy4vdG9hc3QuY29uZmlnJztcblxuZXhwb3J0IGZ1bmN0aW9uIHByb3ZpZGVUb2FzdChcbiAgY29uZmlnOiBQYXJ0aWFsPFRvYXN0Q29uZmlnPiA9IHt9XG4pOiBFbnZpcm9ubWVudFByb3ZpZGVycyB7XG4gIHJldHVybiBtYWtlRW52aXJvbm1lbnRQcm92aWRlcnMoW1xuICAgIHtcbiAgICAgIHByb3ZpZGU6IFRPQVNUX0NPTkZJRyxcbiAgICAgIHVzZUZhY3Rvcnk6ICgpID0+ICh7XG4gICAgICAgIC4uLkRFRkFVTFRfVE9BU1RfQ09ORklHLFxuICAgICAgICAuLi4oY29uZmlnID8/IHt9KSxcbiAgICAgIH0pLFxuICAgIH0sXG4gICAgcHJvdmlkZUFwcEluaXRpYWxpemVyKCgpID0+IHtcbiAgICAgIGJvb3RzdHJhcEdsb2JhbENvbXBvbmVudChUb2FzdENvbXBvbmVudCwgeyByZXVzZUlmRXhpc3RzOiB0cnVlIH0pO1xuICAgIH0pLFxuICBdKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/angular-component-io.mjs

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