@agnos-ui/core 0.4.4 → 0.5.0-next.0

package/types.d.ts

@@ -1,10 +1,25 @@
 import type { ReadableSignal, StoreOptions, SubscribableStore, WritableSignal } from '@amadeus-it-group/tansu';
+/**
+ * A type that maps each property of an object type `T` to either a `ReadableSignal` of that property type or the property type itself.
+ *
+ * @template T - The object type whose properties are being mapped.
+ */
 export type ValuesOrReadableSignals<T extends object> = {
     [K in keyof T]?: ReadableSignal<T[K] | undefined> | T[K];
 };
+/**
+ * A type that maps the properties of an object type `T` to either a `WritableSignal` of the property type or the property type itself.
+ *
+ * @template T - The object type whose properties are being mapped.
+ */
 export type ValuesOrWritableSignals<T extends object> = {
     [K in keyof T]?: WritableSignal<T[K] | undefined> | T[K];
 };
+/**
+ * Interface representing the configuration for properties.
+ *
+ * @template U - An object type representing the properties.
+ */
 export interface PropsConfig<U extends object> {
     /**
      * Object containing, for each property, either its initial value, or a store that will contain the value at any time.
@@ -17,7 +32,16 @@ export interface PropsConfig<U extends object> {
      */
     config?: ReadableSignal<Partial<U>> | ValuesOrReadableSignals<Partial<U>>;
 }
-export interface Widget<Props extends object = object, State extends object = object, Api extends object = object, Actions extends object = object, Directives extends object = object> {
+/**
+ * Represents a generic widget with reactive state, stores, and various functionalities.
+ *
+ * @template Props - The type of the properties that can be passed to the widget.
+ * @template State - The type of the state managed by the widget.
+ * @template Api - The type of the API functions available for interacting with the widget.
+ * @template Actions - The type of the action handlers for user interactions.
+ * @template Directives - The type of the directives used in the widget's template.
+ */
+export interface Widget<Props extends object = object, State extends object = object, Api extends object = object, Directives extends object = object> {
     /**
      * the reactive state of the widget, combining all the values served by the stores
      */
@@ -36,47 +60,65 @@ export interface Widget<Props extends object = object, State extends object = ob
      * directives to be used on html elements in the template of the widget or in the slots
      */
     directives: Directives;
-    /**
-     * all the handlers that should be connected to user interactions i.e. click, keyboard and touch interactions.
-     * typically, the handlers are event listeners that call api functions to affect the widget state
-     */
-    actions: Actions;
     /**
      * all the api functions to interact with the widget
      */
     api: Api;
 }
-export type ContextWidget<W extends Widget> = Pick<W, 'actions' | 'api' | 'directives' | 'state$' | 'stores'>;
-export interface WidgetSlotContext<W extends Widget> {
+/**
+ * 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
      */
     state: WidgetState<W>;
-    /**
-     * the widget
-     */
-    widget: ContextWidget<W>;
 }
 /**
- * Extract actions, api, directives, state and stores from the widget to be passed to slots as context.
+ * Extracts the state type from a widget type that contains a `state$` property.
  *
- * @param w - the widget
- * @returns the slot context
+ * @template T - A type that extends an object with a `state$` property of type `SubscribableStore<any>`.
+ * @returns The type of the state contained within the `state$` property if it extends an object, otherwise `never`.
  */
-export declare const toSlotContextWidget: <W extends Widget>(w: W) => ContextWidget<W>;
 export type WidgetState<T extends {
     state$: SubscribableStore<any>;
 }> = T extends {
     state$: SubscribableStore<infer U extends object>;
 } ? U : never;
+/**
+ * Extracts the type of the argument expected by the `patch` method of a given type `T`.
+ *
+ * This utility type takes a generic type `T` which must have a `patch` method. The `patch` method
+ * should accept an argument that is a partial of some object type `U`. If `T` meets this condition,
+ * `WidgetProps` will resolve to the type `U`. Otherwise, it will resolve to `never`.
+ *
+ * @template T - A type that includes a `patch` method accepting a partial object.
+ */
 export type WidgetProps<T extends {
     patch: (arg: any) => void;
 }> = T extends {
     patch: (arg: Partial<infer U extends object>) => void;
 } ? U : never;
+/**
+ * A factory function type for creating instances of a widget.
+ *
+ * @template W - The type of the widget that extends the base Widget type.
+ * @param props - Optional configuration properties for the widget.
+ * @returns An instance of the widget.
+ */
 export type WidgetFactory<W extends Widget> = (props?: PropsConfig<WidgetProps<W>>) => W;
 /**
- * Subset of HTMLElement that is available in a server side rendering context.
+ * Represents a server-side rendered HTML element with limited functionality.
+ *
+ * This interface extends a subset of the {@link HTMLElement} interface, providing
+ * methods to set and remove attributes, manipulate the element's classes, and
+ * partially manipulate the element's style.
+ *
+ * It inherits the {@link https://developer.mozilla.org/docs/Web/API/Element/setAttribute | setAttribute} and {@link https://developer.mozilla.org/docs/Web/API/Element/getAttribute | getAttribute} methods from the {@link HTMLElement} interface.
+ *
  */
 export interface SSRHTMLElement extends Pick<HTMLElement, 'setAttribute' | 'removeAttribute'> {
     /**
@@ -88,20 +130,72 @@ export interface SSRHTMLElement extends Pick<HTMLElement, 'setAttribute' | 'remo
      */
     style: Partial<Record<StyleKey, StyleValue>>;
 }
+/**
+ * Represents a directive function that can be applied to an SSRHTMLElement.
+ *
+ * @template T - The type of the arguments passed to the directive.
+ * @template U - The type of the SSRHTMLElement, defaults to SSRHTMLElement.
+ *
+ * @param node - The SSRHTMLElement to which the directive is applied.
+ * @param args - The arguments passed to the directive.
+ *
+ * @returns An optional object that may contain:
+ * - `update`: A function to update the directive with new arguments.
+ * - `destroy`: A function to clean up when the directive is no longer needed.
+ */
 export type Directive<T = void, U extends SSRHTMLElement = SSRHTMLElement> = (node: U, args: T) => void | {
     update?: (args: T) => void;
     destroy?: () => void;
 };
+/**
+ * Represents a tuple containing a directive and its associated parameter.
+ *
+ * @template T - The type of the parameter associated with the directive.
+ * @template U - The type of the SSRHTMLElement, defaults to SSRHTMLElement.
+ */
 export type DirectiveAndParam<T, U extends SSRHTMLElement = SSRHTMLElement> = [Directive<T, U>, T];
+/**
+ * Represents a mapping of directives and their optional parameters.
+ *
+ * @template T - An array type representing the parameters for the directives.
+ * @template U - The type of the SSR HTML element, defaults to `SSRHTMLElement`.
+ */
 export type DirectivesAndOptParam<T extends any[], U extends SSRHTMLElement = SSRHTMLElement> = {
     [K in keyof T]: Directive<void, U> | DirectiveAndParam<T[K], U>;
 };
+/**
+ * Represents the content that can be used in a slot.
+ * The content can be one of the following:
+ * - `undefined`
+ * - `null`
+ * - A `string`
+ * - A function that takes `props` of type `Props` and returns a `string`
+ */
 export type SlotContent<Props extends object = object> = undefined | null | string | ((props: Props) => string);
+/**
+ * A unique symbol representing an invalid value.
+ * This can be used as a sentinel value to indicate that a variable or property
+ * does not hold a valid value.
+ */
 export declare const INVALID_VALUE: unique symbol;
+/**
+ * A type alias for a function that normalizes a value of type `T`.
+ * The function takes a value of type `T` and returns either a normalized value of type `T`
+ * or a special constant `INVALID_VALUE` indicating that the value is invalid.
+ *
+ * @template T - The type of the value to be normalized.
+ * @param value - The value to be normalized.
+ * @returns The normalized value of type `T` or `INVALID_VALUE` if the value is invalid.
+ */
 export type NormalizeValue<T> = (value: T) => T | typeof INVALID_VALUE;
+/**
+ * Interface representing options for a writable store with default values.
+ *
+ * @template T - The type of the value stored.
+ */
 export interface WritableWithDefaultOptions<T> {
     /**
-     * the normalize value function. should return the invalidValue symbol when the provided value is invalid
+     * the normalize value function. should return the {@link INVALID_VALUE} symbol when the provided value is invalid
      */
     normalizeValue?: NormalizeValue<T>;
     /**
@@ -109,11 +203,49 @@ export interface WritableWithDefaultOptions<T> {
      */
     equal?: StoreOptions<T>['equal'];
 }
+/**
+ * Represents a type that validates a configuration object.
+ *
+ * @template T - The type of the configuration object to be validated.
+ *
+ * This type maps each key of the configuration object `T` to an optional
+ * `WritableWithDefaultOptions` type, allowing for partial validation.
+ */
 export type ConfigValidator<T extends object> = {
-    [K in keyof T]?: WritableWithDefaultOptions<T[K]>;
+    [K in keyof T]: WritableWithDefaultOptions<T[K]> | undefined;
 };
+/**
+ * Represents a value that can be assigned to an attribute.
+ */
 export type AttributeValue = string | number | boolean | undefined;
+/**
+ * Represents a key of the CSSStyleDeclaration interface, excluding certain properties and methods.
+ *
+ * This is useful for scenarios where you need to work with CSS properties directly without
+ * dealing with the methods and other non-style properties of CSSStyleDeclaration.
+ */
 export type StyleKey = Exclude<keyof CSSStyleDeclaration, 'length' | 'item' | 'parentRule' | 'getPropertyValue' | 'getPropertyPriority' | 'setProperty' | 'removeProperty' | typeof Symbol.iterator | number | 'cssText'>;
+/**
+ * Represents a value that can be used for styling purposes.
+ * @remarks
+ * This type can be a string representing a style value, or it can be undefined or null.
+ * It is useful for scenarios where a style value might be optional or not set.
+ */
 export type StyleValue = string | undefined | null;
+/**
+ * A conditional type that checks if type `T` extends type `U`.
+ * @template T - The type to check.
+ * @template U - The type to check against.
+ * @returns `1` if `T` extends `U`, otherwise `0`.
+ */
 export type Extends<T, U> = T extends U ? 1 : 0;
+/**
+ * Type utility to determine if a given type `T` is or extends `SlotContent<any>`.
+ *
+ * This utility uses conditional types to check if `T` extends `SlotContent<any>` or if `SlotContent<any>` extends `T`.
+ * If either condition is true, it returns `T`, otherwise it returns `0`.
+ *
+ * @template T - The type to be checked.
+ * @returns `T` if `T` is or extends `SlotContent<any>`, otherwise `0`.
+ */
 export type IsSlotContent<T> = Extends<T, SlotContent<any>> | Extends<SlotContent<any>, T> extends 1 ? T : 0;

package/types.js

@@ -1,12 +1,4 @@
-const toSlotContextWidget = (w) => ({
-  actions: w.actions,
-  api: w.api,
-  directives: w.directives,
-  state$: w.state$,
-  stores: w.stores
-});
 const INVALID_VALUE = Symbol();
 export {
-  INVALID_VALUE,
-  toSlotContextWidget
+  INVALID_VALUE
 };

package/utils/directive.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("@amadeus-it-group/tansu");
 require("esm-env");
-const utils_directive = require("../directive-j-xRk-h3.cjs");
+const utils_directive = require("../directive-DdlwGFtf.cjs");
 require("../func-Qd3cD9a3.cjs");
 require("./stores.cjs");
 exports.attributesData = utils_directive.attributesData;

package/utils/directive.d.ts

@@ -8,9 +8,14 @@ import type { AttributeValue, Directive, DirectivesAndOptParam, SSRHTMLElement,
  */
 export declare const isBrowserHTMLElement: (element: SSRHTMLElement) => element is HTMLElement;
 /**
- * Creates a directive that wraps the provided directive to only run it in a browser environment (and not in a server-side rendering environment).
- * @param directive - The directive to run only in a browser.
- * @returns The wrapped directive.
+ * A higher-order directive function that conditionally applies a directive based on the environment.
+ * If running in a browser environment, it applies the given directive to the node.
+ * If not in a browser environment, it returns a no-op function.
+ *
+ * @template T - The type of the directive's argument.
+ * @template U - The type of the HTML element the directive is applied to.
+ * @param directive - The directive to be conditionally applied.
+ * @returns - A directive that applies the given directive in a browser environment, or a no-op in a non-browser environment.
  */
 export declare const browserDirective: <T, U extends HTMLElement>(directive: Directive<T, U>) => Directive<T, SSRHTMLElement>;
 /**
@@ -22,25 +27,33 @@ export declare const browserDirective: <T, U extends HTMLElement>(directive: Dir
  * and will call the provided directive with the content of the provided store as its argument,
  * calling its update method when the content of the store changes.
  *
- * @param directive - directive to bind
- * @param directiveArg$ - store containing the argument of the directive
- * @returns The bound directive that can be used with no argument.
+ * @template T - The type of the directive argument.
+ * @template U - The type of the SSRHTMLElement, defaults to SSRHTMLElement.
+ * @param directive - The directive to bind to the element.
+ * @param directiveArg$ - The signal to subscribe to for directive updates.
+ * @returns A directive that manages the lifecycle of the bound directive.
  */
 export declare const bindDirective: <T, U extends SSRHTMLElement = SSRHTMLElement>(directive: Directive<T, U>, directiveArg$: ReadableSignal<T>) => Directive<void, U>;
 /**
  * Returns a directive that ignores any argument passed to it and calls the provided directive without any
  * argument.
  *
- * @param directive - directive to wrap
- * @returns The resulting directive.
+ * @template T - The type of the directive's argument.
+ * @template U - The type of the SSRHTMLElement, defaults to SSRHTMLElement.
+ * @param directive - The directive to bind without arguments.
+ * @returns A new directive that does not require any arguments.
  */
-export declare const bindDirectiveNoArg: <T, U extends SSRHTMLElement = SSRHTMLElement>(directive: Directive<T | void, U>) => Directive<void, U>;
+export declare const bindDirectiveNoArg: <T, U extends SSRHTMLElement = SSRHTMLElement>(directive: Directive<T, U>) => Directive<void, U>;
 /**
- * Maps the argument to another argument of a directive using a provided function.
+ * Maps the argument of a directive to a new value using a provided function.
+ *
+ * @template T - The type of the original argument.
+ * @template U - The type of the mapped argument.
+ * @template V - The type of the SSRHTMLElement, defaults to SSRHTMLElement.
  *
- * @param directive - The directive to be applied.
- * @param fn - The function to map the argument.
- * @returns A new directive that applies the mapping function to the argument.
+ * @param directive - The original directive to be mapped.
+ * @param fn - The function to map the original argument to the new argument.
+ * @returns A new directive with the mapped argument.
  */
 export declare const mapDirectiveArg: <T, U, V extends SSRHTMLElement = SSRHTMLElement>(directive: Directive<U, V>, fn: (arg: T) => U) => Directive<T, V>;
 /**
@@ -57,13 +70,19 @@ export declare const directiveSubscribe: (store: ReadableSignal<any>, asyncUnsub
  * Returns a directive that calls the provided function with the arguments passed to the directive
  * on initialization and each time they are updated.
  *
+ * @template T - The type of the argument that the update function accepts.
  * @param update - Function called with the directive argument when the directive is initialized and when its argument is updated.
  * @returns The resulting directive.
  */
 export declare const directiveUpdate: <T>(update: (arg: T) => void) => Directive<T>;
 /**
- * Utility to create a store that contains an array of items.
- * @returns a store containing an array of items.
+ * Creates a registration array that allows elements to be added and removed.
+ *
+ * @template T - The type of elements in the array.
+ * @returns An object that includes a readable signal of the array and a register function.
+ *
+ * The returned object has the following properties:
+ * - `register`: A function to add an element to the array. It takes an element of type `T` as a parameter and returns a function to remove the element from the array.
  */
 export declare const registrationArray: <T>() => ReadableSignal<T[]> & {
     register: (element: T) => () => void;
@@ -154,16 +173,28 @@ export declare const createBrowserStoreDirective: () => {
  * All calls to the directives (to create, update and destroy them) are wrapped in a call to the
  * batch function of tansu
  *
- * @param args - directives to merge into a single directive.
- * @returns The resulting merged directive.
+ * @template T - The type of the argument passed to the directive.
+ * @template U - The type of the SSRHTMLElement, defaults to SSRHTMLElement.
+ * @param args - The directives to merge.
+ * @returns A new directive that applies all the given directives.
+ *
+ * The returned directive has the following lifecycle methods:
+ * - `update(arg)`: Updates all merged directives with the given argument.
+ * - `destroy()`: Destroys all merged directives in reverse order.
  */
 export declare const mergeDirectives: <T, U extends SSRHTMLElement = SSRHTMLElement>(...args: (Directive<T, U> | Directive<void, U>)[]) => Directive<T, U>;
 /**
- * Directive that applies all the directives passed as arguments.
+ * Applies multiple directives to a given SSRHTMLElement and provides methods to update or destroy them.
  *
- * @param element - the element to apply the directives to
- * @param directives - the directives to apply
- * @returns The directive instance.
+ * @template T - A tuple type representing the arguments for each directive.
+ * @template U - The type of the SSRHTMLElement, defaults to SSRHTMLElement.
+ *
+ * @param element - The SSRHTMLElement to which the directives will be applied.
+ * @param directives - An array of directives and their optional parameters.
+ *
+ * @returns An object containing:
+ * - `update`: A function to update the directives with new parameters.
+ * - `destroy`: A function to destroy all applied directives.
  */
 export declare const multiDirective: <T extends any[], U extends SSRHTMLElement = SSRHTMLElement>(element: U, directives: DirectivesAndOptParam<T, U>) => {
     update: (directives: DirectivesAndOptParam<any[], U>) => void;
@@ -177,6 +208,7 @@ export interface AttributesDirectiveProps {
      * Events to be attached to an HTML element.
      * @remarks
      * Key-value pairs where keys are event types and values are event handlers.
+xw
      */
     events?: Partial<{
         [K in keyof HTMLElementEventMap]: {
@@ -204,12 +236,17 @@ export interface AttributesDirectiveProps {
     classNames?: Record<string, boolean | ReadableSignal<boolean>>;
 }
 /**
- * Creates a directive for server-side rendering with bindable elements.
- * This directive binds events, attributes, styles, and classNames to an HTML element.
+ * Creates a directive that binds attributes, styles, class names, and events to a DOM node.
+ *
+ * @template T - The type of the arguments passed to the directive.
+ * @param propsFn - A function that takes a readable signal of type `T` and returns an object containing
+ *                  attributes, styles, class names, and events to bind to the node.
+ * @returns A directive function that can be used to bind the specified properties to a DOM node.
  *
- * @param propsFn - A function that returns the AttributesDirectiveProps with the data to bind.
- * This function can take an optional parameter that corrspond to the second parameter of the created directive.
- * @returns A directive object with bound events, attributes, styles, and classNames.
+ * The returned directive function takes a DOM node and arguments of type `T`, and sets up the bindings
+ * specified by the `propsFn` function. It returns an object with `update` and `destroy` methods:
+ * - `update(args: T)`: Updates the arguments passed to the directive.
+ * - `destroy()`: Cleans up all bindings and event listeners.
  */
 export declare const createAttributesDirective: <T = void>(propsFn: (arg: ReadableSignal<T>) => AttributesDirectiveProps) => Directive<T>;
 /**
@@ -219,6 +256,7 @@ export declare const createAttributesDirective: <T = void>(propsFn: (arg: Readab
  *   - The `classNames` value is an array of string representing the classes to be applied
  *   - The `style` value is a JSON representation of the styles to be applied
  *
+ * @template T - The type of the directives array.
  * @param directives - List of directives to generate attributes from. Each parameter can be the directive or an array with the directive and its parameter
  * @returns JSON object with the `attributes`, `class` and `style` keys.
  */
@@ -232,15 +270,26 @@ export declare const attributesData: <T extends any[]>(...directives: Directives
  */
 export declare const classDirective: Directive<string>;
 /**
- * Returns JSON representation of the attributes to be applied derived from a list of directives.
+ * Combines multiple directives into a single attributes object.
  *
- * @param directives - List of directives to generate attributes from. Each parameter can be the directive or an array with the directive and its parameter
- * @returns JSON object with name/value for the attributes
+ * This function processes an array of directives and optional parameters,
+ * extracting attributes, class names, and styles. It then combines these
+ * into a single attributes object, where class names are joined into a
+ * single string and styles are formatted as a CSS string.
+ *
+ * @template T - The type of the directives and optional parameters.
+ * @param directives - The directives and optional parameters to process.
+ * @returns An object containing the combined attributes.
  */
 export declare function directiveAttributes<T extends any[]>(...directives: DirectivesAndOptParam<T>): Record<string, string>;
 /**
- * Same as {@link directiveAttributes}, but returns an empty object when run in a browser environement.
+ * Generates a record of SSR (Server-Side Rendering) attributes based on the provided directives.
+ *
+ * This function behaves differently depending on the environment:
+ * - In a browser environment (`BROWSER` is true), it returns an empty object.
+ * - In a non-browser environment, it delegates to the `directiveAttributes` function.
  *
- * @returns JSON object with name/value for the attributes
+ * @template T - A tuple type representing the directives and optional parameters.
+ * @returns A record of SSR attributes.
  */
-export declare const ssrAttributes: (() => {}) | typeof directiveAttributes;
+export declare const ssrAttributes: <T extends any[]>(...directives: DirectivesAndOptParam<T>) => Record<string, string>;

package/utils/directive.js

@@ -1,6 +1,6 @@
 import "@amadeus-it-group/tansu";
 import "esm-env";
-import { o, a, c, b, p, n, g, j, f, h, q, d, e, i, m, k, l, r, s } from "../directive-3-8yr-ZK.js";
+import { o, a, c, b, p, n, g, j, f, h, q, d, e, i, m, k, l, r, s } from "../directive-CKEccryv.js";
 import "../func-DR0n-ShK.js";
 import "./stores.js";
 export {

package/utils/internal/checks.d.ts

@@ -47,3 +47,9 @@ export declare const isHTMLElement: (value: any) => value is HTMLElement;
  * @returns A type guard function that returns true for null values and calls the provided type guard for other values.
  */
 export declare const allowNull: <T>(isType: (value: any) => value is T) => (value: any) => value is T | null;
+/**
+ * Builds a new type guard to check if an element belongs to an enum list
+ * @param list - the list of all enum values
+ * @returns the type guard
+ */
+export declare function isFromEnum<T>(list: T[]): (value: any) => value is T;

package/utils/internal/dom.d.ts

@@ -1,4 +1,4 @@
-import type { ReadableSignal } from '@amadeus-it-group/tansu';
+import type { ReadableSignal, UnsubscribeFunction, UnsubscribeObject } from '@amadeus-it-group/tansu';
 import type { AttributeValue, SSRHTMLElement, StyleKey, StyleValue } from '../../types';
 /**
  * Returns the common ancestor of the provided DOM elements.
@@ -7,7 +7,7 @@ import type { AttributeValue, SSRHTMLElement, StyleKey, StyleValue } from '../..
  */
 export declare const computeCommonAncestor: (elements: HTMLElement[]) => HTMLElement | null;
 /**
- * Launch a reflow using a call to the provided html element getBoudingClientRect
+ * Launch a reflow using a call to the provided html element getBoundingClientRect
  * @param element - the html element
  */
 export declare const reflow: (element?: SSRHTMLElement) => void;
@@ -15,7 +15,7 @@ export declare const reflow: (element?: SSRHTMLElement) => void;
  * Attach the given css classes to the element
  *
  * @param element - the HTML element
- * @param classes - the css lcasses
+ * @param classes - the css classes
  */
 export declare const addClasses: (element: SSRHTMLElement, classes?: string[]) => void;
 /**
@@ -53,7 +53,7 @@ export declare const generateId: () => string;
  *
  * @returns unsubscription method to remove the binding
  */
-export declare function bindAttribute(node: SSRHTMLElement, attributeName: string, value$: ReadableSignal<AttributeValue>): import("@amadeus-it-group/tansu").UnsubscribeFunction & import("@amadeus-it-group/tansu").UnsubscribeObject;
+export declare function bindAttribute(node: SSRHTMLElement, attributeName: string, value$: ReadableSignal<AttributeValue>): UnsubscribeFunction & UnsubscribeObject;
 /**
  * Binds a value from a `ReadableSignal` to the specified CSS style property of an HTML element.
  * When the value emitted by the signal changes, it updates the style property accordingly.
@@ -65,7 +65,7 @@ export declare function bindAttribute(node: SSRHTMLElement, attributeName: strin
  *
  * @returns unsubscription method to remove the binding
  */
-export declare function bindStyle(node: SSRHTMLElement, styleName: StyleKey, value$: ReadableSignal<StyleValue>): import("@amadeus-it-group/tansu").UnsubscribeFunction & import("@amadeus-it-group/tansu").UnsubscribeObject;
+export declare function bindStyle(node: SSRHTMLElement, styleName: StyleKey, value$: ReadableSignal<StyleValue>): UnsubscribeFunction & UnsubscribeObject;
 /**
  * Binds a `ReadableSignal` of boolean to the specified className of an HTML element.
  * The className is added when the value is true, removed otherwise

package/utils/internal/promise.d.ts

@@ -1,9 +1,18 @@
 import type { ReadableSignal } from '@amadeus-it-group/tansu';
+/**
+ * Represents the result of a promise that is still pending.
+ */
 export interface PromisePendingResult {
     /** Pending status */
     status: 'pending';
 }
+/**
+ * A constant representing a pending promise result.
+ */
 export declare const promisePending: PromisePendingResult;
+/**
+ * Represents the state of a promise, which can be either fulfilled, rejected, or pending.
+ */
 export type PromiseState<T> = PromiseFulfilledResult<T> | PromiseRejectedResult | PromisePendingResult;
 /**
  * Create a readable promise state store from a promise.

package/utils/internal/sort.d.ts

@@ -5,9 +5,9 @@
  * @param b - the second input
  * @returns 1, 0 or -1 depending on the default compare
  */
-export declare const compareDefault: (a: any, b: any) => 0 | 1 | -1;
+export declare const compareDefault: (a: any, b: any) => -1 | 0 | 1;
 /**
- * A comparision function between DOM elements, based on [Node.compareDocumentPosition](https://developer.mozilla.org/fr/docs/Web/API/Node/compareDocumentPosition).
+ * A comparision function between DOM elements, based on {@link https://developer.mozilla.org/fr/docs/Web/API/Node/compareDocumentPosition | Node.compareDocumentPosition}.
  *
  * @param element1 - the first node
  * @param element2 - the second node

package/utils/internal/ssrHTMLElement.d.ts

@@ -1,4 +1,8 @@
 import type { SSRHTMLElement } from '../../types';
+/**
+ * A unique symbol used to represent the attributes and style of an SSR (Server-Side Rendering) HTML element.
+ * This symbol can be used as a key for storing or retrieving attributes and styles associated with an SSR HTML element.
+ */
 export declare const ssrHTMLElementAttributesAndStyle: unique symbol;
 /**
  * Create an SSRHTMLElement

package/utils/stores.cjs

@@ -7,7 +7,7 @@ function createPatch(stores) {
   return function(storesValues) {
     tansu.batch(() => {
       var _a;
-      for (const [name, value] of Object.entries(storesValues ?? {})) {
+      for (const [name, value] of Object.entries(storesValues)) {
         (_a = stores[`${name}$`]) == null ? void 0 : _a.set(value);
       }
     });