@agnos-ui/angular-headless 0.0.1-alpha.1 → 0.0.1-alpha.4

package/lib/config.d.ts

@@ -0,0 +1,50 @@
+import type { Partial2Levels, Widget, WidgetFactory, WidgetProps, WidgetsConfigStore } from '@agnos-ui/core';
+import type { ReadableSignal } from '@amadeus-it-group/tansu';
+import type { FactoryProvider } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import type { AdaptPropsSlots } from './slotTypes';
+import type { WithPatchSlots } from './utils';
+export type WidgetsConfig = {
+    [WidgetName in keyof import('@agnos-ui/core').WidgetsConfig]: AdaptPropsSlots<import('@agnos-ui/core').WidgetsConfig[WidgetName]>;
+};
+export declare const widgetsConfigFactory: <Config extends {
+    [widgetName: string]: object;
+} = WidgetsConfig>(widgetsConfigInjectionToken?: InjectionToken<WidgetsConfigStore<Config>>) => {
+    /**
+     * Dependency Injection token which can be used to provide or inject the widgets default configuration store.
+     */
+    widgetsConfigInjectionToken: InjectionToken<WidgetsConfigStore<Config>>;
+    provideWidgetsConfig: (adaptParentConfig?: ((config: Partial<{ [Level1 in keyof Config]: Partial<Config[Level1]>; }>) => Partial<{ [Level1 in keyof Config]: Partial<Config[Level1]>; }>) | undefined) => FactoryProvider;
+    injectWidgetsConfig: () => WidgetsConfigStore<Config>;
+    injectWidgetConfig: <N extends keyof Config>(widgetName: N) => ReadableSignal<Partial<Config[N]> | undefined>;
+    callWidgetFactory: <W extends Widget<object, object, object, object, object>>({ factory, widgetName, defaultConfig, events, }: {
+        factory: WidgetFactory<W>;
+        widgetName?: keyof Config | null | undefined;
+        defaultConfig?: Partial<WidgetProps<W>> | ReadableSignal<Partial<WidgetProps<W>> | undefined> | undefined;
+        events: Pick<WidgetProps<W>, keyof WidgetProps<W> & `on${string}`>;
+    }) => WithPatchSlots<W>;
+};
+export declare const widgetsConfigInjectionToken: InjectionToken<WidgetsConfigStore<WidgetsConfig>>, provideWidgetsConfig: (adaptParentConfig?: ((config: Partial<{
+    pagination: Partial<AdaptPropsSlots<import("@agnos-ui/core").PaginationProps>>;
+    rating: Partial<AdaptPropsSlots<import("@agnos-ui/core").RatingProps>>;
+    select: Partial<AdaptPropsSlots<import("@agnos-ui/core").SelectProps<any>>>;
+    modal: Partial<AdaptPropsSlots<import("@agnos-ui/core").ModalProps>>;
+    alert: Partial<AdaptPropsSlots<import("@agnos-ui/core").AlertProps>>;
+    accordion: Partial<AdaptPropsSlots<import("@agnos-ui/core").AccordionProps>>;
+    progressbar: Partial<AdaptPropsSlots<import("@agnos-ui/core").ProgressbarProps>>;
+    slider: Partial<AdaptPropsSlots<import("@agnos-ui/core").SliderProps>>;
+}>) => Partial<{
+    pagination: Partial<AdaptPropsSlots<import("@agnos-ui/core").PaginationProps>>;
+    rating: Partial<AdaptPropsSlots<import("@agnos-ui/core").RatingProps>>;
+    select: Partial<AdaptPropsSlots<import("@agnos-ui/core").SelectProps<any>>>;
+    modal: Partial<AdaptPropsSlots<import("@agnos-ui/core").ModalProps>>;
+    alert: Partial<AdaptPropsSlots<import("@agnos-ui/core").AlertProps>>;
+    accordion: Partial<AdaptPropsSlots<import("@agnos-ui/core").AccordionProps>>;
+    progressbar: Partial<AdaptPropsSlots<import("@agnos-ui/core").ProgressbarProps>>;
+    slider: Partial<AdaptPropsSlots<import("@agnos-ui/core").SliderProps>>;
+}>) | undefined) => FactoryProvider, injectWidgetConfig: <N extends keyof import("@agnos-ui/core").WidgetsConfig>(widgetName: N) => ReadableSignal<Partial<WidgetsConfig[N]> | undefined>, injectWidgetsConfig: () => WidgetsConfigStore<WidgetsConfig>, callWidgetFactory: <W extends Widget<object, object, object, object, object>>({ factory, widgetName, defaultConfig, events, }: {
+    factory: WidgetFactory<W>;
+    widgetName?: keyof import("@agnos-ui/core").WidgetsConfig | null | undefined;
+    defaultConfig?: Partial<WidgetProps<W>> | ReadableSignal<Partial<WidgetProps<W>> | undefined> | undefined;
+    events: Pick<WidgetProps<W>, keyof WidgetProps<W> & `on${string}`>;
+}) => WithPatchSlots<W>;

package/lib/slot.directive.d.ts

@@ -1,5 +1,5 @@
 import type { OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
-import type { SlotContent } from './utils';
+import type { SlotContent } from './slotTypes';
 import * as i0 from "@angular/core";
 export declare class SlotDirective<Props extends Record<string, any>> implements OnChanges, OnDestroy {
     slot: SlotContent<Props>;

package/lib/slotDefault.directive.d.ts

@@ -1,7 +1,7 @@
 import type { WritableSignal } from '@amadeus-it-group/tansu';
 import type { OnInit } from '@angular/core';
 import { TemplateRef } from '@angular/core';
-import type { SlotContent } from './utils';
+import type { SlotContent } from './slotTypes';
 import * as i0 from "@angular/core";
 export declare class SlotDefaultDirective<T extends object> implements OnInit {
     auSlotDefault: WritableSignal<{

package/lib/slotTypes.d.ts

@@ -0,0 +1,18 @@
+import type { SlotContent as CoreSlotContent, Widget, WidgetFactory, WidgetProps, WidgetSlotContext, WidgetState } from '@agnos-ui/core';
+import type { TemplateRef, Type } from '@angular/core';
+export declare class ComponentTemplate<Props, K extends string, T extends {
+    [key in K]: TemplateRef<Props>;
+}> {
+    readonly component: Type<T>;
+    readonly templateProp: K;
+    constructor(component: Type<T>, templateProp: K);
+}
+export type SlotContent<Props extends object = object> = CoreSlotContent<Props> | TemplateRef<Props> | Type<unknown> | ComponentTemplate<Props, any, any>;
+export type AdaptSlotContentProps<Props extends Record<string, any>> = Props extends WidgetSlotContext<infer U> ? WidgetSlotContext<AdaptWidgetSlots<U>> & AdaptPropsSlots<Omit<Props, keyof WidgetSlotContext<any>>> : AdaptPropsSlots<Props>;
+export type AdaptPropsSlots<Props> = Omit<Props, `slot${string}`> & {
+    [K in keyof Props & `slot${string}`]: Props[K] extends CoreSlotContent<infer U> ? SlotContent<AdaptSlotContentProps<U>> : Props[K];
+};
+export type AdaptWidgetFactories<T> = {
+    [K in keyof T]: T[K] extends WidgetFactory<infer U> ? WidgetFactory<AdaptWidgetSlots<U>> : T[K];
+};
+export type AdaptWidgetSlots<W extends Widget> = Widget<AdaptPropsSlots<WidgetProps<W>>, AdaptPropsSlots<WidgetState<W>>, AdaptWidgetFactories<W['api']>, W['actions'], W['directives']>;

package/lib/use.directive.d.ts

@@ -1,12 +1,14 @@
-import type { OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import type { OnChanges } from '@angular/core';
 import type { Directive as AgnosUIDirective } from '@agnos-ui/core';
 import * as i0 from "@angular/core";
-export declare class UseDirective<T> implements OnChanges, OnDestroy {
+export declare const useDirectiveForHost: <T>(use?: AgnosUIDirective<T> | undefined, params?: T | undefined) => {
+    update: (newUse?: AgnosUIDirective<T> | undefined, newParams?: T | undefined) => Promise<void>;
+};
+export declare class UseDirective<T> implements OnChanges {
     #private;
     use: AgnosUIDirective<T> | undefined;
     params: T | undefined;
-    ngOnChanges(changes: SimpleChanges): Promise<void>;
-    ngOnDestroy(): void;
+    ngOnChanges(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<UseDirective<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<UseDirective<any>, "[auUse]", never, { "use": { "alias": "auUse"; "required": false; }; "params": { "alias": "auUseParams"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/utils.d.ts

@@ -1,95 +1,17 @@
-import type { SlotContent as CoreSlotContent, WidgetsConfig as CoreWidgetsConfig, Partial2Levels, Widget, WidgetFactory, WidgetProps, WidgetSlotContext, WidgetState, WidgetsConfigStore } from '@agnos-ui/core';
-import type { ReadableSignal, SubscribableStore } from '@amadeus-it-group/tansu';
-import type { FactoryProvider, SimpleChanges, TemplateRef, Type } from '@angular/core';
-import { InjectionToken } from '@angular/core';
-export declare class ComponentTemplate<Props, K extends string, T extends {
-    [key in K]: TemplateRef<Props>;
-}> {
-    readonly component: Type<T>;
-    readonly templateProp: K;
-    constructor(component: Type<T>, templateProp: K);
-}
-export type SlotContent<Props extends object = object> = CoreSlotContent<Props> | TemplateRef<Props> | Type<unknown> | ComponentTemplate<Props, any, any>;
-export type AdaptSlotContentProps<Props extends Record<string, any>> = Props extends WidgetSlotContext<infer U> ? WidgetSlotContext<AdaptWidgetSlots<U>> & AdaptPropsSlots<Omit<Props, keyof WidgetSlotContext<any>>> : AdaptPropsSlots<Props>;
-export type AdaptPropsSlots<Props> = Omit<Props, `slot${string}`> & {
-    [K in keyof Props & `slot${string}`]: Props[K] extends CoreSlotContent<infer U> ? SlotContent<AdaptSlotContentProps<U>> : Props[K];
-};
-export type AdaptWidgetSlots<W extends Widget> = Widget<AdaptPropsSlots<WidgetProps<W>>, AdaptPropsSlots<WidgetState<W>>, W['api'], W['actions'], W['directives']>;
-export type WidgetsConfig = {
-    [WidgetName in keyof CoreWidgetsConfig]: AdaptPropsSlots<CoreWidgetsConfig[WidgetName]>;
-};
-/**
- * Dependency Injection token which can be used to provide or inject the widgets default configuration store.
- */
-export declare const widgetsConfigInjectionToken: InjectionToken<WidgetsConfigStore<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
- *       }
- *     });
- *   }
- *   // ...
- * }
- * ```
- */
-export declare const provideWidgetsConfig: (adaptParentConfig?: ((config: Partial2Levels<WidgetsConfig>) => Partial2Levels<WidgetsConfig>) | undefined) => FactoryProvider;
-/**
- * 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.
- */
-export declare const injectWidgetsConfig: () => WidgetsConfigStore<WidgetsConfig>;
-export type WithPatchSlots<W extends Widget> = AdaptWidgetSlots<W> & {
+import type { Widget, WidgetFactory, WidgetProps } from '@agnos-ui/core';
+import type { ReadableSignal } from '@amadeus-it-group/tansu';
+import type { Signal, SimpleChanges, TemplateRef } from '@angular/core';
+import type { SlotContent } from './slotTypes';
+export declare const toAngularSignal: <T>(tansuSignal: ReadableSignal<T>) => Signal<T>;
+export type WithPatchSlots<W extends Widget> = W & {
     patchSlots(slots: {
-        [K in keyof WidgetProps<W> & `slot${string}`]: WidgetProps<W>[K] extends CoreSlotContent<infer U> ? TemplateRef<AdaptSlotContentProps<U>> | undefined : never;
+        [K in keyof WidgetProps<W> & `slot${string}`]: WidgetProps<W>[K] extends SlotContent<infer U> ? TemplateRef<U> | undefined : never;
     }): void;
 };
-export declare const callWidgetFactory: <W extends Widget<object, object, object, object, object>>(factory: WidgetFactory<W>, widgetName: keyof WidgetsConfig | null, defaultConfig?: Partial<AdaptPropsSlots<WidgetProps<W>>> | ReadableSignal<Partial<AdaptPropsSlots<WidgetProps<W>>>>) => WithPatchSlots<W>;
+export declare const callWidgetFactoryWithConfig: <W extends Widget<object, object, object, object, object>>({ factory, defaultConfig, widgetConfig, events, }: {
+    factory: WidgetFactory<W>;
+    defaultConfig?: Partial<WidgetProps<W>> | ReadableSignal<Partial<WidgetProps<W>> | undefined> | undefined;
+    widgetConfig?: ReadableSignal<Partial<WidgetProps<W>> | undefined> | null | undefined;
+    events: Pick<WidgetProps<W>, keyof WidgetProps<W> & `on${string}`>;
+}) => WithPatchSlots<W>;
 export declare function patchSimpleChanges(patchFn: (obj: any) => void, changes: SimpleChanges): void;
-export type ExtractStoreType<T> = T extends SubscribableStore<infer U> ? U : never;

package/package.json

@@ -6,12 +6,12 @@
 		"@angular/core": "*"
 	},
 	"dependencies": {
-		"@agnos-ui/core": "0.0.1-alpha.1",
-		"@amadeus-it-group/tansu": "0.0.22",
+		"@agnos-ui/core": "0.0.1-alpha.4",
+		"@amadeus-it-group/tansu": "0.0.23",
 		"tslib": "^2.6.2"
 	},
 	"sideEffects": false,
-	"version": "0.0.1-alpha.1",
+	"version": "0.0.1-alpha.4",
 	"module": "fesm2022/agnos-ui-angular-headless.mjs",
 	"typings": "index.d.ts",
 	"exports": {
@@ -42,6 +42,7 @@
 		"alert",
 		"modal",
 		"pagination",
-		"rating"
+		"rating",
+		"slider"
 	]
 }

package/public-api.d.ts

@@ -1,34 +1,52 @@
 export * from '@agnos-ui/core';
+export * from './lib/config';
+export type { WidgetsConfig } from './lib/config';
 export * from './lib/slot.directive';
 export * from './lib/slotDefault.directive';
+export * from './lib/slotTypes';
+export type { SlotContent } from './lib/slotTypes';
 export * from './lib/use.directive';
 export * from './lib/utils';
-export type { SlotContent, WidgetsConfig } from './lib/utils';
-import type { WidgetProps, WidgetState } from '@agnos-ui/core';
-import type { AdaptSlotContentProps, AdaptWidgetSlots } from './lib/utils';
+import type { PropsConfig, WidgetFactory, WidgetProps, WidgetState } from '@agnos-ui/core';
+import type { AdaptSlotContentProps, AdaptWidgetSlots } from './lib/slotTypes';
 export type AccordionWidget = AdaptWidgetSlots<import('@agnos-ui/core').AccordionWidget>;
 export type AccordionProps = WidgetProps<AccordionWidget>;
 export type AccordionState = WidgetState<AccordionWidget>;
+export type AccordionApi = AccordionWidget['api'];
 export type AccordionItemWidget = AdaptWidgetSlots<import('@agnos-ui/core').AccordionItemWidget>;
 export type AccordionItemProps = WidgetProps<AccordionItemWidget>;
 export type AccordionItemState = WidgetState<AccordionItemWidget>;
 export type AccordionItemContext = AdaptSlotContentProps<import('@agnos-ui/core').AccordionItemContext>;
+export declare const createAccordion: WidgetFactory<AccordionWidget>;
 export type AlertWidget = AdaptWidgetSlots<import('@agnos-ui/core').AlertWidget>;
 export type AlertProps = WidgetProps<AlertWidget>;
 export type AlertState = WidgetState<AlertWidget>;
 export type AlertContext = AdaptSlotContentProps<import('@agnos-ui/core').AlertContext>;
+export declare const createAlert: WidgetFactory<AlertWidget>;
 export type ModalWidget = AdaptWidgetSlots<import('@agnos-ui/core').ModalWidget>;
 export type ModalProps = WidgetProps<ModalWidget>;
 export type ModalState = WidgetState<ModalWidget>;
 export type ModalContext = AdaptSlotContentProps<import('@agnos-ui/core').ModalContext>;
+export declare const createModal: WidgetFactory<ModalWidget>;
 export type PaginationWidget = AdaptWidgetSlots<import('@agnos-ui/core').PaginationWidget>;
 export type PaginationProps = WidgetProps<PaginationWidget>;
 export type PaginationState = WidgetState<PaginationWidget>;
 export type PaginationContext = AdaptSlotContentProps<import('@agnos-ui/core').PaginationContext>;
 export type PaginationNumberContext = AdaptSlotContentProps<import('@agnos-ui/core').PaginationNumberContext>;
+export declare const createPagination: WidgetFactory<PaginationWidget>;
 export type RatingWidget = AdaptWidgetSlots<import('@agnos-ui/core').RatingWidget>;
 export type RatingProps = WidgetProps<RatingWidget>;
 export type RatingState = WidgetState<RatingWidget>;
+export declare const createRating: WidgetFactory<RatingWidget>;
 export type SelectWidget<Item> = AdaptWidgetSlots<import('@agnos-ui/core').SelectWidget<Item>>;
 export type SelectProps<Item> = WidgetProps<SelectWidget<Item>>;
 export type SelectState<Item> = WidgetState<SelectWidget<Item>>;
+export declare const createSelect: <Item>(propsConfig?: PropsConfig<SelectProps<Item>>) => SelectWidget<Item>;
+export type SliderWidget = AdaptWidgetSlots<import('@agnos-ui/core').SliderWidget>;
+export type SliderProps = WidgetProps<SliderWidget>;
+export type SliderState = WidgetState<SliderWidget>;
+export type ProgressbarWidget = AdaptWidgetSlots<import('@agnos-ui/core').ProgressbarWidget>;
+export type ProgressbarProps = WidgetProps<ProgressbarWidget>;
+export type ProgressbarState = WidgetState<ProgressbarWidget>;
+export type ProgressbarContext = AdaptSlotContentProps<import('@agnos-ui/core').ProgressbarContext>;
+export declare const createProgressbar: WidgetFactory<ProgressbarWidget>;