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

package/fesm2022/agnos-ui-angular-headless.mjs

@@ -1,9 +1,192 @@
-import { toReadableStore, createWidgetsConfig, createAccordion as createAccordion$1, createAlert as createAlert$1, createModal as createModal$1, createPagination as createPagination$1, createRating as createRating$1, createSelect as createSelect$1, createProgressbar as createProgressbar$1 } from '@agnos-ui/core';
-export * from '@agnos-ui/core';
-import { DOCUMENT } from '@angular/common';
+import { createAccordion as createAccordion$1 } from '@agnos-ui/core/components/accordion';
+export * from '@agnos-ui/core/components/accordion';
+import { createAlert as createAlert$1 } from '@agnos-ui/core/components/alert';
+export * from '@agnos-ui/core/components/alert';
+import { createModal as createModal$1 } from '@agnos-ui/core/components/modal';
+export * from '@agnos-ui/core/components/modal';
+import { createPagination as createPagination$1 } from '@agnos-ui/core/components/pagination';
+export * from '@agnos-ui/core/components/pagination';
+import { createProgressbar as createProgressbar$1 } from '@agnos-ui/core/components/progressbar';
+export * from '@agnos-ui/core/components/progressbar';
+import { createRating as createRating$1 } from '@agnos-ui/core/components/rating';
+export * from '@agnos-ui/core/components/rating';
+import { createSelect as createSelect$1 } from '@agnos-ui/core/components/select';
+export * from '@agnos-ui/core/components/select';
+export * from '@agnos-ui/core/components/slider';
+export * from '@agnos-ui/core/services/siblingsInert';
+export * from '@agnos-ui/core/services/portal';
+export * from '@agnos-ui/core/services/navManager';
+export * from '@agnos-ui/core/services/intersection';
+export * from '@agnos-ui/core/services/focustrack';
+export * from '@agnos-ui/core/services/floatingUI';
+export * from '@agnos-ui/core/services/extendWidget';
+export * from '@agnos-ui/core/services/transitions/simpleClassTransition';
+export * from '@agnos-ui/core/services/transitions/cssTransitions';
+export * from '@agnos-ui/core/services/transitions/collapse';
+export * from '@agnos-ui/core/services/transitions/bootstrap';
+export * from '@agnos-ui/core/services/transitions/baseTransitions';
+export * from '@agnos-ui/core/utils/writables';
 import * as i0 from '@angular/core';
-import { createComponent, EnvironmentInjector, TemplateRef, reflectComponentType, inject, ViewContainerRef, Directive, Input, ElementRef, Injector, runInInjectionContext, SkipSelf, Optional, InjectionToken } from '@angular/core';
+import { NgZone, inject, Injectable, signal, DestroyRef, ElementRef, Directive, Input, Injector, runInInjectionContext, SkipSelf, Optional, InjectionToken, booleanAttribute, numberAttribute, TemplateRef, EnvironmentInjector, createComponent, reflectComponentType, ViewContainerRef } from '@angular/core';
+import { toReadableStore } from '@agnos-ui/core/utils/stores';
+export * from '@agnos-ui/core/utils/stores';
+export * from '@agnos-ui/core/utils/directive';
+import { toSlotContextWidget } from '@agnos-ui/core/types';
+export * from '@agnos-ui/core/types';
+import { createWidgetsConfig } from '@agnos-ui/core/config';
+export * from '@agnos-ui/core/config';
 import { writable, computed } from '@amadeus-it-group/tansu';
+import { DOCUMENT } from '@angular/common';
+
+const createAccordion = createAccordion$1;
+
+const createAlert = createAlert$1;
+
+const createModal = createModal$1;
+
+const createPagination = createPagination$1;
+
+const createProgressbar = createProgressbar$1;
+
+const createRating = createRating$1;
+
+const createSelect = createSelect$1;
+
+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);
+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); })();
+
+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;
+};
+
+// 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.
+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 };
+};
+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']
+        }] }); })();
 
 class ComponentTemplate {
     constructor(component, templateProp) {
@@ -11,6 +194,275 @@ class ComponentTemplate {
         this.templateProp = templateProp;
     }
 }
+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
+        }] }); })();
+
+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);
+        }
+    };
+};
+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
+ */
+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;
+    };
+};
+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); })();
+
+const widgetsConfigFactory = (widgetsConfigInjectionToken = new InjectionToken('widgetsConfig')) => {
+    /**
+     * Creates a provider of widgets default configuration that inherits from any widgets default configuration already defined at an upper level
+     * in the Angular dependency injection system. It contains its own set of widgets configuration properties that override the same properties form
+     * the parent configuration.
+     *
+     * @remarks
+     * The configuration is computed from the parent configuration in two steps:
+     * - first step: the parent configuration is transformed by the adaptParentConfig function (if specified).
+     * If adaptParentConfig is not specified, this step is skipped.
+     * - second step: the configuration from step 1 is merged (2-levels deep) with the own$ store. The own$ store initially contains
+     * an empty object (i.e. no property from the parent is overridden). It can be changed by calling set on the store returned by
+     * {@link injectWidgetsConfig}.
+     *
+     * @param adaptParentConfig - optional function that receives a 2-levels copy of the widgets default configuration
+     * defined at an upper level in the Angular dependency injection system (or an empty object if there is none) and returns the widgets
+     * default configuration to be used.
+     * It is called only if the configuration is needed, and was not yet computed for the current value of the parent configuration.
+     * It is called in a tansu reactive context, so it can use any tansu store and will be called again if those stores change.
+     * It is also called in an Angular injection context, so it can call the Angular inject function to get and use dependencies from the
+     * Angular dependency injection system.
+
+    * @returns DI provider to be included a list of `providers` (for example at a component level or
+    * any other level of the Angular dependency injection system)
+    *
+    * @example
+    * ```typescript
+    * @Component({
+    *   // ...
+    *   providers: [
+    *     provideWidgetsConfig((parentConfig) => {
+    *       // first step configuration: transforms the parent configuration
+    *       parentConfig.rating = parentConfig.rating ?? {};
+    *       parentConfig.rating.className = `${parentConfig.rating.className ?? ''} my-rating-extra-class`
+    *       return parentConfig;
+    *     })
+    *   ]
+    * })
+    * class MyComponent {
+    *   widgetsConfig = injectWidgetsConfig();
+    *   constructor() {
+    *     this.widgetsConfig.set({
+    *       // second step configuration: overrides the parent configuration
+    *       rating: {
+    *         slotStar: MyCustomSlotStar
+    *       }
+    *     });
+    *   }
+    *   // ...
+    * }
+    * ```
+    */
+    const provideWidgetsConfig = (adaptParentConfig) => ({
+        provide: widgetsConfigInjectionToken,
+        useFactory: (parent) => {
+            if (adaptParentConfig) {
+                const injector = inject(Injector);
+                const originalAdaptParentConfig = adaptParentConfig;
+                adaptParentConfig = (value) => runInInjectionContext(injector, () => originalAdaptParentConfig(value));
+            }
+            return createWidgetsConfig(parent ?? undefined, adaptParentConfig);
+        },
+        deps: [[new SkipSelf(), new Optional(), widgetsConfigInjectionToken]],
+    });
+    /**
+     * Returns the widgets default configuration store that was provided in the current injection context.
+     * Throws if the no widgets default configuration store was provided.
+     *
+     * @remarks
+     * This function must be called from an injection context, such as a constructor, a factory function, a field initializer or
+     * a function used with {@link https://angular.io/api/core/runInInjectionContext | runInInjectionContext}.
+     *
+     * @returns the widgets default configuration store.
+     */
+    const injectWidgetsConfig = () => inject(widgetsConfigInjectionToken);
+    const injectWidgetConfig = (widgetName) => {
+        const widgetsConfig = inject(widgetsConfigInjectionToken, { optional: true });
+        return computed(() => widgetsConfig?.()[widgetName]);
+    };
+    const callWidgetFactory = ({ factory, widgetName = null, defaultConfig = {}, events, afterInit, }) => callWidgetFactoryWithConfig({
+        factory,
+        widgetConfig: widgetName ? injectWidgetConfig(widgetName) : null,
+        defaultConfig,
+        events,
+        afterInit,
+    });
+    return {
+        /**
+         * Dependency Injection token which can be used to provide or inject the widgets default configuration store.
+         */
+        widgetsConfigInjectionToken,
+        provideWidgetsConfig,
+        injectWidgetsConfig,
+        injectWidgetConfig,
+        callWidgetFactory,
+    };
+};
+const { widgetsConfigInjectionToken, provideWidgetsConfig, injectWidgetConfig, injectWidgetsConfig, callWidgetFactory } = widgetsConfigFactory();
+
+/**
+ * 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.
+ */
+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;
+ *  ```
+ */
+function auNumberAttribute(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return numberAttribute(value);
+}
+
+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']
+        }] }); })();
 
 class SlotHandler {
     constructor(viewContainerRef, document) {
@@ -190,251 +642,30 @@ class SlotDirective {
         this._slotHandler?.destroy();
         this._slotHandler = undefined;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SlotDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.9", type: SlotDirective, isStandalone: true, selector: "[auSlot]", inputs: { slot: ["auSlot", "slot"], props: ["auSlotProps", "props"] }, usesOnChanges: true, ngImport: i0 }); }
+    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] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SlotDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[auSlot]',
-                    standalone: true,
-                }]
-        }], propDecorators: { slot: [{
-                type: Input,
-                args: ['auSlot']
-            }], props: [{
-                type: Input,
-                args: ['auSlotProps']
-            }] } });
-
-class SlotDefaultDirective {
-    constructor() {
-        this.templateRef = inject((TemplateRef));
-    }
-    ngOnInit() {
-        this.auSlotDefault.update((value) => ({ ...value, slotDefault: this.templateRef }));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SlotDefaultDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.9", type: SlotDefaultDirective, isStandalone: true, selector: "[auSlotDefault]", inputs: { auSlotDefault: "auSlotDefault" }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SlotDefaultDirective, decorators: [{
-            type: Directive,
-            args: [{ selector: '[auSlotDefault]', standalone: true }]
-        }], propDecorators: { auSlotDefault: [{
-                type: Input,
-                args: ['auSlotDefault']
-            }] } });
-
-// 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.
-class UseDirective {
-    #ref = inject(ElementRef);
-    #directive;
-    #directiveInstance;
-    async #destroyDirectiveInstance() {
-        const directiveInstance = this.#directiveInstance;
-        this.#directiveInstance = undefined;
-        if (directiveInstance?.destroy) {
-            await 0;
-            directiveInstance.destroy?.();
-        }
-    }
-    async ngOnChanges(changes) {
-        if (this.use !== this.#directive) {
-            this.#destroyDirectiveInstance();
-            const directive = this.use;
-            this.#directive = directive;
-            if (directive) {
-                await 0;
-                // checks that the directive did not change while waiting:
-                if (directive === this.#directive && !this.#directiveInstance) {
-                    this.#directiveInstance = directive(this.#ref.nativeElement, this.params);
-                }
-            }
-        }
-        else if (changes['params']) {
-            await 0;
-            this.#directiveInstance?.update?.(this.params);
-        }
-    }
-    ngOnDestroy() {
-        this.#destroyDirectiveInstance();
-        this.#directive = undefined;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: UseDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.9", type: UseDirective, isStandalone: true, selector: "[auUse]", inputs: { use: ["auUse", "use"], params: ["auUseParams", "params"] }, usesOnChanges: true, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: UseDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    standalone: true,
-                    selector: '[auUse]',
-                }]
-        }], propDecorators: { use: [{
-                type: Input,
-                args: ['auUse']
-            }], params: [{
-                type: Input,
-                args: ['auUseParams']
-            }] } });
-
-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);
-        }
-    };
-};
-const callWidgetFactoryWithConfig = ({ factory, defaultConfig, widgetConfig, events, }) => {
-    const defaultConfig$ = toReadableStore(defaultConfig);
-    const slots$ = writable({});
-    const widget = factory({
-        config: computed(() => ({ ...defaultConfig$(), ...widgetConfig?.(), ...slots$() })),
-    });
-    widget.patch(events);
-    return {
-        ...widget,
-        patchSlots: createPatchSlots(slots$.set),
-    };
-};
-function patchSimpleChanges(patchFn, changes) {
-    const obj = {};
-    for (const [key, simpleChange] of Object.entries(changes)) {
-        if (simpleChange !== undefined) {
-            obj[key] = simpleChange.currentValue;
-        }
-    }
-    patchFn(obj);
-}
-
-const widgetsConfigFactory = (widgetsConfigInjectionToken = new InjectionToken('widgetsConfig')) => {
-    /**
-     * Creates a provider of widgets default configuration that inherits from any widgets default configuration already defined at an upper level
-     * in the Angular dependency injection system. It contains its own set of widgets configuration properties that override the same properties form
-     * the parent configuration.
-     *
-     * @remarks
-     * The configuration is computed from the parent configuration in two steps:
-     * - first step: the parent configuration is transformed by the adaptParentConfig function (if specified).
-     * If adaptParentConfig is not specified, this step is skipped.
-     * - second step: the configuration from step 1 is merged (2-levels deep) with the own$ store. The own$ store initially contains
-     * an empty object (i.e. no property from the parent is overridden). It can be changed by calling set on the store returned by
-     * {@link injectWidgetsConfig}.
-     *
-     * @param adaptParentConfig - optional function that receives a 2-levels copy of the widgets default configuration
-     * defined at an upper level in the Angular dependency injection system (or an empty object if there is none) and returns the widgets
-     * default configuration to be used.
-     * It is called only if the configuration is needed, and was not yet computed for the current value of the parent configuration.
-     * It is called in a tansu reactive context, so it can use any tansu store and will be called again if those stores change.
-     * It is also called in an Angular injection context, so it can call the Angular inject function to get and use dependencies from the
-     * Angular dependency injection system.
-
-    * @returns DI provider to be included a list of `providers` (for example at a component level or
-    * any other level of the Angular dependency injection system)
-    *
-    * @example
-    * ```typescript
-    * @Component({
-    *   // ...
-    *   providers: [
-    *     provideWidgetsConfig((parentConfig) => {
-    *       // first step configuration: transforms the parent configuration
-    *       parentConfig.rating = parentConfig.rating ?? {};
-    *       parentConfig.rating.className = `${parentConfig.rating.className ?? ''} my-rating-extra-class`
-    *       return parentConfig;
-    *     })
-    *   ]
-    * })
-    * class MyComponent {
-    *   widgetsConfig = injectWidgetsConfig();
-    *   constructor() {
-    *     this.widgetsConfig.set({
-    *       // second step configuration: overrides the parent configuration
-    *       rating: {
-    *         slotStar: MyCustomSlotStar
-    *       }
-    *     });
-    *   }
-    *   // ...
-    * }
-    * ```
-    */
-    const provideWidgetsConfig = (adaptParentConfig) => ({
-        provide: widgetsConfigInjectionToken,
-        useFactory: (parent) => {
-            if (adaptParentConfig) {
-                const injector = inject(Injector);
-                const originalAdaptParentConfig = adaptParentConfig;
-                adaptParentConfig = (value) => runInInjectionContext(injector, () => originalAdaptParentConfig(value));
-            }
-            return createWidgetsConfig(parent ?? undefined, adaptParentConfig);
-        },
-        deps: [[new SkipSelf(), new Optional(), widgetsConfigInjectionToken]],
-    });
-    /**
-     * Returns the widgets default configuration store that was provided in the current injection context.
-     * Throws if the no widgets default configuration store was provided.
-     *
-     * @remarks
-     * This function must be called from an injection context, such as a constructor, a factory function, a field initializer or
-     * a function used with {@link https://angular.io/api/core/runInInjectionContext | runInInjectionContext}.
-     *
-     * @returns the widgets default configuration store.
-     */
-    const injectWidgetsConfig = () => inject(widgetsConfigInjectionToken);
-    const injectWidgetConfig = (widgetName) => {
-        const widgetsConfig = inject(widgetsConfigInjectionToken, { optional: true });
-        return computed(() => widgetsConfig?.()[widgetName]);
-    };
-    const callWidgetFactory = ({ factory, widgetName = null, defaultConfig = {}, events, }) => callWidgetFactoryWithConfig({
-        factory,
-        widgetConfig: widgetName ? injectWidgetConfig(widgetName) : null,
-        defaultConfig,
-        events,
-    });
-    return {
-        /**
-         * Dependency Injection token which can be used to provide or inject the widgets default configuration store.
-         */
-        widgetsConfigInjectionToken,
-        provideWidgetsConfig,
-        injectWidgetsConfig,
-        injectWidgetConfig,
-        callWidgetFactory,
-    };
-};
-const { widgetsConfigInjectionToken, provideWidgetsConfig, injectWidgetConfig, injectWidgetsConfig, callWidgetFactory } = widgetsConfigFactory();
+(() => { (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']
+        }] }); })();
 
 /*
  * Public API Surface of @agnos-ui/angular-headless
  */
-const createAccordion = createAccordion$1;
-const createAlert = createAlert$1;
-const createModal = createModal$1;
-const createPagination = createPagination$1;
-const createRating = createRating$1;
-const createSelect = createSelect$1;
-const createProgressbar = createProgressbar$1;
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { ComponentTemplate, SlotDefaultDirective, SlotDirective, UseDirective, callWidgetFactory, callWidgetFactoryWithConfig, createAccordion, createAlert, createModal, createPagination, createProgressbar, createRating, createSelect, injectWidgetConfig, injectWidgetsConfig, patchSimpleChanges, provideWidgetsConfig, widgetsConfigFactory, widgetsConfigInjectionToken };
+export { BaseWidgetDirective, CachedProperty, ComponentTemplate, SlotComponent, SlotDefaultDirective, SlotDirective, UseDirective, ZoneWrapper, auBooleanAttribute, auNumberAttribute, callWidgetFactory, callWidgetFactoryWithConfig, createAccordion, createAlert, createModal, createPagination, createProgressbar, createRating, createSelect, injectWidgetConfig, injectWidgetsConfig, provideWidgetsConfig, toAngularSignal, useDirectiveForHost, widgetsConfigFactory, widgetsConfigInjectionToken };
 //# sourceMappingURL=agnos-ui-angular-headless.mjs.map