@agnos-ui/angular-headless 0.8.1 → 0.9.0

package/generated/services/siblingsInert.d.ts

@@ -1 +0,0 @@
-export * from '@agnos-ui/core/services/siblingsInert';

package/generated/services/transitions/baseTransitions.d.ts

@@ -1 +0,0 @@
-export * from '@agnos-ui/core/services/transitions/baseTransitions';

package/generated/services/transitions/collapse.d.ts

@@ -1 +0,0 @@
-export * from '@agnos-ui/core/services/transitions/collapse';

package/generated/services/transitions/cssTransitions.d.ts

@@ -1 +0,0 @@
-export * from '@agnos-ui/core/services/transitions/cssTransitions';

package/generated/services/transitions/simpleClassTransition.d.ts

@@ -1 +0,0 @@
-export * from '@agnos-ui/core/services/transitions/simpleClassTransition';

package/generated/slot.directive.d.ts

@@ -1 +0,0 @@
-export * from './../slot.directive';

package/generated/types.d.ts

@@ -1 +0,0 @@
-export * from './../types';

package/generated/utils/coercion.d.ts

@@ -1 +0,0 @@
-export * from './../../utils/coercion';

package/generated/utils/directive.d.ts

@@ -1 +0,0 @@
-export * from './../../utils/directive';

package/generated/utils/func.d.ts

@@ -1 +0,0 @@
-export * from '@agnos-ui/core/utils/func';

package/generated/utils/stores.d.ts

@@ -1 +0,0 @@
-export * from './../../utils/stores';

package/generated/utils/widget.d.ts

@@ -1 +0,0 @@
-export * from './../../utils/widget';

package/generated/utils/writables.d.ts

@@ -1 +0,0 @@
-export * from '@agnos-ui/core/utils/writables';

package/generated/utils/zone.d.ts

@@ -1 +0,0 @@
-export * from './../../utils/zone';

package/slot.directive.d.ts

@@ -1,34 +0,0 @@
-import type { OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
-import type { SlotContent } from './types';
-import * as i0 from "@angular/core";
-/**
- * A directive that manages slot content and its properties.
- *
- * @template Props - A record type representing the properties for the slot.
- *
- * @remarks
- * This directive handles changes to the slot content and its properties,
- * and manages the lifecycle of the slot handler.
- */
-export declare class SlotDirective<Props extends Record<string, any>> implements OnChanges, OnDestroy {
-    /**
-     * The slot content to be managed.
-     */
-    readonly slot: import("@angular/core").InputSignal<SlotContent<Props>>;
-    /**
-     * The properties for the slot content.
-     */
-    readonly props: import("@angular/core").InputSignal<Props>;
-    private readonly _viewContainerRef;
-    private _slotType;
-    private _slotHandler;
-    /**
-     * @param changes SimpleChanges from Angular
-     * @internal
-     */
-    ngOnChanges(changes: SimpleChanges): void;
-    /** @internal */
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlotDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<SlotDirective<any>, "[auSlot]", never, { "slot": { "alias": "auSlot"; "required": true; "isSignal": true; }; "props": { "alias": "auSlotProps"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/types.d.ts

@@ -1,116 +0,0 @@
-import type { SlotContent as CoreSlotContent, Widget, WidgetState, Extends } from '@agnos-ui/core/types';
-import type { Signal, TemplateRef, Type } from '@angular/core';
-import * as i0 from "@angular/core";
-export * from '@agnos-ui/core/types';
-/**
- * Represents a template for a component with specified properties.
- *
- * @template Props - The type of properties that the template accepts.
- * @template K - The key in the template object that maps to the template reference.
- * @template T - An object type where each key of type K maps to a TemplateRef of Props.
- *
- * @param component - The component type that contains the template.
- * @param templateProp - The key in the component that maps to the template reference.
- */
-export declare class ComponentTemplate<Props, K extends string, T extends {
-    [key in K]: Signal<TemplateRef<Props>>;
-}> {
-    readonly component: Type<T>;
-    readonly templateProp: K;
-    constructor(component: Type<T>, templateProp: K);
-}
-/**
- * Represents the content that can be used in a slot.
- *
- * @template Props - The type of the properties that the slot content can accept.
- *
- * This type can be one of the following:
- * - `undefined | null`: Nullish value
- * - `string`: A static string
- * - `(props: Props) => string`: A function that takes props as input and returns a string template
- * - `TemplateRef<Props>`: A reference to an Angular template with the specified properties.
- * - `Type<unknown>`: A type representing an unknown component or directive.
- * - `ComponentTemplate<Props, any, any>`: A component template with the specified properties.
- */
-export type SlotContent<Props extends object = object> = CoreSlotContent<Props> | TemplateRef<Props> | Type<unknown> | ComponentTemplate<Props, any, any>;
-/**
- * A directive representing a slot component that can be used to manage the state and context of a widget.
- *
- * @template W - The type of the widget that this slot component manages.
- */
-export declare abstract class SlotComponent<W extends Widget> {
-    /**
-     * The state of the widget. Each property of the state is exposed through an Angular {@link https://angular.dev/api/core/Signal | Signal}
-     */
-    readonly state: import("@angular/core").InputSignal<AngularState<W>>;
-    /**
-     * all the api functions to interact with the widget
-     */
-    readonly api: import("@angular/core").InputSignal<W["api"]>;
-    /**
-     * directives to be used on html elements in the template of the slot
-     */
-    readonly directives: import("@angular/core").InputSignal<W["directives"]>;
-    /**
-     * The slot context, to be used when the slot component uses other slots.
-     */
-    readonly slotContext: Signal<{
-        state: AngularState<W>;
-        api: W["api"];
-        directives: W["directives"];
-    }>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SlotComponent<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<SlotComponent<any>, never, never, { "state": { "alias": "state"; "required": true; "isSignal": true; }; "api": { "alias": "api"; "required": true; "isSignal": true; }; "directives": { "alias": "directives"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-/**
- * Type utility to determine if a given type `T` is or extends `SlotContent<any>`.
- *
- * This type alias uses conditional types to check if `T` extends `SlotContent<any>` or if `SlotContent<any>` extends `T`.
- * If either condition is true, it resolves to `T`, otherwise it resolves to `0`.
- *
- * @template T - The type to be checked.
- */
-export type IsSlotContent<T> = Extends<T, SlotContent<any>> | Extends<SlotContent<any>, T> extends 1 ? T : 0;
-/**
- * Represents the state of an Angular widget, where each key in the widget's state
- * is mapped to a Signal of the corresponding state value.
- *
- * @template W - The type of the widget.
- */
-export type AngularState<W extends Widget> = {
-    [key in keyof WidgetState<W>]: Signal<WidgetState<W>[key]>;
-};
-/**
- * Represents an Angular widget that extends a base widget type.
- *
- * @template W - The type of the base widget.
- */
-export interface AngularWidget<W extends Widget> extends Pick<W, 'api' | 'directives' | 'patch'> {
-    /**
-     * A promise that resolves when the widget is initialized
-     */
-    initialized: Promise<void>;
-    /**
-     * The state of the widget. Each property of the state is exposed through an Angular {@link https://angular.dev/api/core/Signal | Signal}
-     */
-    state: AngularState<W>;
-    /**
-     * A function to initialize the Angular widget.
-     */
-    ngInit: () => void;
-    /**
-     * A utility function to update the slot properties.
-     */
-    updateSlots: () => void;
-}
-/**
- * Represents the context for a widget slot, providing access to the widget and its state.
- *
- * @template W - The type of the widget.
- */
-export interface WidgetSlotContext<W extends Widget> extends Pick<W, 'api' | 'directives'> {
-    /**
-     * The state of the widget. Each property of the state is exposed through an Angular {@link https://angular.dev/api/core/Signal | Signal}
-     */
-    state: AngularState<W>;
-}

package/utils/coercion.d.ts

@@ -1,20 +0,0 @@
-/**
- * Transforms a value (typically a string) to a boolean.
- * Intended to be used as a transform function of an input.
- *
- * @example
- * ```readonly status = input({ transform: auBooleanAttribute });```
- * @param value - Value to be transformed.
- * @returns the value transformed
- */
-export declare function auBooleanAttribute(value: unknown): boolean | undefined;
-/**
- * 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.
- *
- * @example
- *  ```readonly id = input({ transform: auNumberAttribute });```
- * @returns the value transformed
- */
-export declare function auNumberAttribute(value: unknown): number | undefined;

package/utils/directive.d.ts

@@ -1,54 +0,0 @@
-import type { Directive as AgnosUIDirective, DirectiveAndParam, DirectivesAndOptParam } from '@agnos-ui/core/types';
-import type { OnChanges } from '@angular/core';
-import * as i0 from "@angular/core";
-export * from '@agnos-ui/core/utils/directive';
-/**
- * A utility function to manage the lifecycle of a directive for a host element.
- *
- * This function handles the creation, updating, and destruction of a directive instance
- * associated with a host element. It ensures that the directive is called appropriately
- * based on the platform (server or client) and manages the directive's lifecycle within
- * the Angular injection context.
- *
- * @template T - The type of parameters that the directive accepts.
- *
- * @param [directive] - The directive to be applied to the host element.
- * @param [params] - The parameters to be passed to the directive.
- *
- * @returns An object containing an `update` function to update the directive and its parameters.
- */
-export declare const useDirectiveForHost: <T>(directive?: AgnosUIDirective<T>, params?: T) => {
-    update: (newDirective?: AgnosUIDirective<T>, newParams?: T) => void;
-};
-/**
- * A directive that allows the use of another directive with optional parameters.
- *
- * @template T - The type of the parameter that can be passed to the directive.
- *
- * @remarks
- * This directive uses a private instance of {@link useDirectiveForHost} to manage the directive and its parameter.
- */
-export declare class UseDirective<T> implements OnChanges {
-    #private;
-    readonly use: import("@angular/core").InputSignal<AgnosUIDirective | DirectiveAndParam<T>>;
-    /** @internal */
-    ngOnChanges(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<UseDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<UseDirective<any>, "[auUse]", never, { "use": { "alias": "auUse"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-/**
- * A directive that allows the use of multiple directives on a host element.
- *
- * @template T - A tuple type representing the directives and their optional parameters.
- */
-export declare class UseMultiDirective<T extends any[]> implements OnChanges {
-    #private;
-    /**
-     * An input property that takes a tuple of directives and their optional parameters.
-     */
-    readonly useMulti: import("@angular/core").InputSignal<DirectivesAndOptParam<T, import("@agnos-ui/angular-headless").SSRHTMLElement>>;
-    /** @internal */
-    ngOnChanges(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<UseMultiDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<UseMultiDirective<any>, "[auUseMulti]", never, { "useMulti": { "alias": "auUseMulti"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/utils/stores.d.ts

@@ -1,31 +0,0 @@
-import type { ReadableSignal, WritableSignal as TansuWritableSignal } from '@amadeus-it-group/tansu';
-import type { Signal, WritableSignal } from '@angular/core';
-export * from '@agnos-ui/core/utils/stores';
-/**
- * Converts a Tansu `ReadableSignal` to an Angular `Signal`.
- *
- * This function wraps the provided Tansu signal in an Angular signal, ensuring that updates
- * are properly handled within Angular's zone. It subscribes to the Tansu signal and updates
- * the Angular signal with the received values. The equality function for the Angular signal
- * is set to always return false, ensuring that every new value from the Tansu signal triggers
- * an update.
- *
- * @template T - The type of the value emitted by the signals.
- * @param tansuSignal - The Tansu signal to convert.
- * @returns - The resulting Angular signal.
- */
-export declare const toAngularSignal: <T>(tansuSignal: ReadableSignal<T>) => Signal<T>;
-/**
- * Converts a Tansu `WritableSignal` to an Angular `WritableSignal`.
- *
- * This function wraps the provided Tansu signal in an Angular signal, ensuring that updates
- * are properly handled within Angular's zone. It subscribes to the Tansu signal and updates
- * the Angular signal with the received values. The equality function for the Angular signal
- * is set to always return false, ensuring that every new value from the Tansu signal triggers
- * an update.
- *
- * @template T - The type of the value emitted by the signals.
- * @param tansuSignal - The Tansu signal to convert.
- * @returns - The resulting Angular signal.
- */
-export declare const toAngularWritableSignal: <T>(tansuSignal: TansuWritableSignal<T>) => WritableSignal<T>;

package/utils/widget.d.ts

@@ -1,62 +0,0 @@
-import { type ReadableSignal } from '@amadeus-it-group/tansu';
-import type { AfterContentChecked, OnChanges, OnInit, SimpleChanges, TemplateRef } from '@angular/core';
-import type { AngularState, AngularWidget, IsSlotContent, SlotContent, Widget, WidgetFactory, WidgetProps } from '../types';
-import * as i0 from "@angular/core";
-/**
- * Call a widget factory using provided configs.
- *
- * @param parameter - the parameter
- * @param parameter.factory - the widget factory to call
- * @param parameter.defaultConfig - the default config of the widget
- * @param parameter.widgetConfig - the config of the widget, overriding the defaultConfig
- * @param parameter.events - the events of the widget
- * @param parameter.afterInit - a callback to call after successful setup of the widget
- * @param parameter.slotTemplates - a function to provide all slot templates using child queries
- * @param parameter.slotChildren - a function to provide the default children slot using a view query
- * @returns the widget
- */
-export declare const callWidgetFactoryWithConfig: <W extends Widget>({ factory, defaultConfig, widgetConfig, events, afterInit, slotTemplates, slotChildren, }: {
-    factory: WidgetFactory<W>;
-    defaultConfig?: Partial<WidgetProps<W>> | ReadableSignal<Partial<WidgetProps<W>> | undefined>;
-    widgetConfig?: null | undefined | ReadableSignal<Partial<WidgetProps<W>> | undefined>;
-    events?: Partial<Pick<WidgetProps<W>, keyof WidgetProps<W> & `on${string}`>>;
-    afterInit?: (widget: AngularWidget<W>) => void;
-    slotTemplates?: () => { [K in keyof WidgetProps<W> as IsSlotContent<WidgetProps<W>[K]> extends 0 ? never : K]: WidgetProps<W>[K] extends SlotContent<infer U> ? TemplateRef<U> | undefined : never; };
-    slotChildren?: () => TemplateRef<void> | undefined;
-}) => AngularWidget<W>;
-/**
- * An abstract base class for widget directives, providing common functionality
- * for Angular components that interact with widgets.
- *
- * @template W - The type of the widget.
- */
-export declare abstract class BaseWidgetDirective<W extends Widget> implements OnChanges, OnInit, AfterContentChecked {
-    private readonly _widget;
-    constructor(_widget: AngularWidget<W>);
-    /**
-     * Retrieves the widget api
-     * @returns the widget api
-     */
-    get api(): W['api'];
-    /**
-     * Retrieves the widget state. Each property of the state is exposed through an Angular {@link https://angular.dev/api/core/Signal | Signal}
-     * @returns the widget state
-     */
-    get state(): AngularState<W>;
-    /**
-     * Retrieves the widget directives
-     * @returns the widget directives
-     */
-    get directives(): W['directives'];
-    /**
-     * @inheritdoc
-     * @internal
-     */
-    ngOnChanges(changes: SimpleChanges): void;
-    /** @internal */
-    ngOnInit(): void;
-    /** @internal */
-    ngAfterContentChecked(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BaseWidgetDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseWidgetDirective<any>, never, never, {}, {}, never, never, true, never>;
-}

package/utils/zone.d.ts

@@ -1,26 +0,0 @@
-import * as i0 from "@angular/core";
-type Wrapper = <T>(fn: T) => T;
-/**
- * A utility class that provides methods to run functions inside or outside of Angular's NgZone.
- * This can be useful for optimizing performance by avoiding unnecessary change detection cycles.
- */
-export declare class ZoneWrapper {
-    #private;
-    planNgZoneRun: () => void;
-    /**
-     * Run the input function synchronously within the Angular zone
-     *
-     * @param fn - a function to run
-     * @returns the value returned by the function
-     */
-    ngZoneRun<T>(fn: () => T): T;
-    insideNgZone: Wrapper;
-    insideNgZoneWrapFunctionsObject: Wrapper;
-    outsideNgZone: Wrapper;
-    outsideNgZoneWrapFunctionsObject: Wrapper;
-    outsideNgZoneWrapDirective: Wrapper;
-    outsideNgZoneWrapDirectivesObject: Wrapper;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ZoneWrapper, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ZoneWrapper>;
-}
-export {};