@agnos-ui/core 0.0.1-alpha.4 → 0.0.1-alpha.5

package/services/transitions/bootstrap.js

@@ -0,0 +1,2 @@
+export * from './bootstrap/collapse';
+export * from './bootstrap/fade';

package/{transitions → services/transitions}/collapse.js

@@ -1,5 +1,5 @@
 import { createCSSTransition } from './cssTransitions';
-import { addClasses, reflow, removeClasses } from './utils';
+import { addClasses, reflow, removeClasses } from '../../utils/internal/dom';
 export const createCollapseTransition = ({ dimension = 'height', showClasses, hideClasses, animationPendingClasses } = {}) => createCSSTransition((element, direction, animation, context) => {
     if (animation) {
         let { maxSize, minSize } = context;

package/{transitions → services/transitions}/cssTransitions.js

@@ -1,4 +1,5 @@
-import { promiseFromEvent, promiseFromTimeout } from './utils';
+import { noop } from '../../utils/internal/func';
+import { promiseFromEvent, promiseFromTimeout } from '../../utils/internal/promise';
 /**
  * Check if the provided html element has a transition
  * @param element - the html element
@@ -18,9 +19,6 @@ export function getTransitionDurationMs(element) {
     const transitionDurationSec = parseFloat(transitionDuration);
     return (transitionDelaySec + transitionDurationSec) * 1000;
 }
-const noop = () => {
-    /* do nothing */
-};
 export const createCSSTransition = (start) => async (element, direction, animation, signal, context) => {
     const endFn = start(element, direction, animation, context) ?? noop;
     if (animation && hasTransition(element)) {

package/{transitions → services/transitions}/simpleClassTransition.js

@@ -1,5 +1,5 @@
 import { createCSSTransition } from './cssTransitions';
-import { addClasses, reflow, removeClasses } from './utils';
+import { addClasses, reflow, removeClasses } from '../../utils/internal/dom';
 export const createSimpleClassTransition = ({ animationPendingClasses, animationPendingShowClasses, animationPendingHideClasses, showClasses, hideClasses, }) => createCSSTransition((element, direction, animation, context) => {
     removeClasses(element, showClasses);
     removeClasses(element, hideClasses);

package/types.d.ts

@@ -1,5 +1,22 @@
-import type { ReadableSignal, SubscribableStore } from '@amadeus-it-group/tansu';
-import type { PropsConfig } from './services';
+import type { ReadableSignal, StoreOptions, SubscribableStore, WritableSignal } from '@amadeus-it-group/tansu';
+export type ValuesOrReadableSignals<T extends object> = {
+    [K in keyof T]?: ReadableSignal<T[K] | undefined> | T[K];
+};
+export type ValuesOrWritableSignals<T extends object> = {
+    [K in keyof T]?: WritableSignal<T[K] | undefined> | T[K];
+};
+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.
+     * When the value of a property is undefined or invalid, the value from the config is used.
+     */
+    props?: ValuesOrWritableSignals<U>;
+    /**
+     * Either a store of objects containing, for each property, the default value,
+     * or an object containing, for each property, either a store containing the default value or the default value itself.
+     */
+    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> {
     /**
      * the reactive state of the widget, combining all the values served by the stores
@@ -29,6 +46,7 @@ export interface Widget<Props extends object = object, State extends object = ob
      */
     api: Api;
 }
+export type ContextWidget<W extends Widget> = Pick<W, 'actions' | 'api' | 'directives' | 'state$' | 'stores'>;
 export interface WidgetSlotContext<W extends Widget> {
     /**
      * the state of the widget
@@ -37,9 +55,9 @@ export interface WidgetSlotContext<W extends Widget> {
     /**
      * the widget
      */
-    widget: Pick<W, 'actions' | 'api' | 'directives' | 'state$' | 'stores'>;
+    widget: ContextWidget<W>;
 }
-export declare const toSlotContextWidget: <W extends Widget<object, object, object, object, object>>(w: W) => Pick<W, "actions" | "api" | "directives" | "state$" | "stores">;
+export declare const toSlotContextWidget: <W extends Widget<object, object, object, object, object>>(w: W) => ContextWidget<W>;
 export type WidgetState<T extends {
     state$: SubscribableStore<any>;
 }> = T extends {
@@ -56,3 +74,18 @@ export type Directive<T = void> = (node: HTMLElement, args: T) => void | {
     destroy?: () => void;
 };
 export type SlotContent<Props extends object = object> = undefined | null | string | ((props: Props) => string);
+export declare const INVALID_VALUE: unique symbol;
+export type NormalizeValue<T> = (value: T) => T | typeof INVALID_VALUE;
+export interface WritableWithDefaultOptions<T> {
+    /**
+     * the normalize value function. should return the invalidValue symbol when the provided value is invalid
+     */
+    normalizeValue?: NormalizeValue<T>;
+    /**
+     * the equal function, allowing to compare two values. used to check if a previous and current values are equals.
+     */
+    equal?: StoreOptions<T>['equal'];
+}
+export type ConfigValidator<T extends object> = {
+    [K in keyof T]?: WritableWithDefaultOptions<T[K]>;
+};

package/types.js

@@ -5,3 +5,4 @@ export const toSlotContextWidget = (w) => ({
     state$: w.state$,
     stores: w.stores,
 });
+export const INVALID_VALUE = Symbol();

package/{services/directiveUtils.js → utils/directive.js}

@@ -1,5 +1,5 @@
 import { asReadable, batch, readable, writable } from '@amadeus-it-group/tansu';
-import { noop } from '../utils';
+import { noop } from './internal/func';
 /**
  * Binds the given directive to a store that provides its argument.
  *

package/{services → utils/internal}/checks.d.ts

@@ -35,3 +35,15 @@ export declare const isArray: (arg: any) => arg is any[];
  * @returns the clamped value
  */
 export declare function clamp(value: number, max: number, min?: number): number;
+/**
+ * an html element type guard
+ * @param value the value to check
+ * @returns true if the value is an instance of HTMLElement
+ */
+export declare const isHTMLElement: (value: any) => value is HTMLElement;
+/**
+ * Returns a new type guard that is based on the provided type guard and also returns true for null values.
+ * @param isType base type guard
+ * @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;

package/{services → utils/internal}/checks.js

@@ -46,3 +46,15 @@ export const isArray = Array.isArray;
 export function clamp(value, max, min = 0) {
     return Math.max(Math.min(value, max), min);
 }
+/**
+ * an html element type guard
+ * @param value the value to check
+ * @returns true if the value is an instance of HTMLElement
+ */
+export const isHTMLElement = (value) => value instanceof HTMLElement;
+/**
+ * Returns a new type guard that is based on the provided type guard and also returns true for null values.
+ * @param isType base type guard
+ * @returns A type guard function that returns true for null values and calls the provided type guard for other values.
+ */
+export const allowNull = (isType) => (value) => value === null || isType(value);

package/utils/internal/dom.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns the common ancestor of the provided DOM elements.
+ * @param elements - array of DOM elements
+ * @returns the common ancestor, or null if the array is empty or if there is no common ancestor (e.g.: if elements are detached)
+ */
+export declare const computeCommonAncestor: (elements: HTMLElement[]) => HTMLElement | null;
+/**
+ * Launch a reflow using a call to the provided html element getBoudingClientRect
+ * @param element - the html element
+ */
+export declare function reflow(element?: HTMLElement): void;
+export declare const addClasses: (element: HTMLElement, classes?: string[]) => void;
+export declare const removeClasses: (element: HTMLElement, classes?: string[]) => void;

package/utils/internal/dom.js

@@ -0,0 +1,49 @@
+/**
+ * Returns the common ancestor of the provided DOM elements.
+ * @param elements - array of DOM elements
+ * @returns the common ancestor, or null if the array is empty or if there is no common ancestor (e.g.: if elements are detached)
+ */
+export const computeCommonAncestor = (elements) => {
+    const length = elements.length;
+    if (length === 0)
+        return null;
+    let ancestor = elements[0];
+    for (let i = 1; i < length && ancestor; i++) {
+        const element = elements[i];
+        while (ancestor) {
+            if (ancestor === element) {
+                break;
+            }
+            const comparison = ancestor.compareDocumentPosition(element);
+            if (comparison & Node.DOCUMENT_POSITION_CONTAINED_BY) {
+                break;
+            }
+            else if (comparison & Node.DOCUMENT_POSITION_CONTAINS) {
+                ancestor = element;
+                break;
+            }
+            else if (comparison & Node.DOCUMENT_POSITION_DISCONNECTED) {
+                return null;
+            }
+            ancestor = ancestor.parentElement;
+        }
+    }
+    return ancestor;
+};
+/**
+ * Launch a reflow using a call to the provided html element getBoudingClientRect
+ * @param element - the html element
+ */
+export function reflow(element = document.body) {
+    element.getBoundingClientRect();
+}
+export const addClasses = (element, classes) => {
+    if (classes && classes.length > 0) {
+        element.classList.add(...classes);
+    }
+};
+export const removeClasses = (element, classes) => {
+    if (classes && classes.length > 0) {
+        element.classList.remove(...classes);
+    }
+};

package/utils/internal/math.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param number - decimal number
+ * @returns the decimal precision of the number
+ */
+export declare function getDecimalPrecision(number: number): number;

package/utils/internal/math.js

@@ -0,0 +1,13 @@
+const decimalRegExp = /(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
+/**
+ * @param number - decimal number
+ * @returns the decimal precision of the number
+ */
+export function getDecimalPrecision(number) {
+    const matches = ('' + number).match(decimalRegExp);
+    return Math.max(0, 
+    // Number of digits right of decimal point.
+    (matches[1]?.length ?? 0) -
+        // Adjust for exponential notation.
+        (+matches[2] || 0));
+}

package/utils/internal/promise.d.ts

@@ -0,0 +1,31 @@
+import type { ReadableSignal } from '@amadeus-it-group/tansu';
+export interface PromisePendingResult {
+    /** Pending status */
+    status: 'pending';
+}
+export declare const promisePending: PromisePendingResult;
+export type PromiseState<T> = PromiseFulfilledResult<T> | PromiseRejectedResult | PromisePendingResult;
+export declare const promiseStateStore: <T>(value: T) => ReadableSignal<Readonly<PromiseState<Awaited<T>>>>;
+export declare const promiseStoreToPromiseStateStore: <T>(promiseStore$: ReadableSignal<T>) => ReadableSignal<PromiseState<Awaited<T>>>;
+export declare const promiseStateStoreToValueStore: <T>(store$: ReadableSignal<PromiseState<T>>, initialValue: T, equal?: ((a: T, b: T) => boolean) | undefined) => ReadableSignal<T>;
+export declare const promiseStoreToValueStore: <T>(promiseStore$: ReadableSignal<T>, initialValue: Awaited<T>, equal?: ((a: Awaited<T>, b: Awaited<T>) => boolean) | undefined) => ReadableSignal<Awaited<T>>;
+export declare const promiseFromStore: <T>(store: ReadableSignal<T>, condition?: (value: T) => boolean) => {
+    promise: Promise<T>;
+    unsubscribe(): void;
+};
+export declare const promiseFromEvent: (element: EventTarget, event: string) => {
+    promise: Promise<Event>;
+    unsubscribe(): void;
+};
+export declare const promiseFromTimeout: (delay: number) => {
+    promise: Promise<void>;
+    unsubscribe(): void;
+};
+/**
+ * Utility method to create a promise with resolve
+ * @returns a promise with resolve
+ */
+export declare const promiseWithResolve: () => {
+    promise: Promise<void>;
+    resolve: (value: void | Promise<void>) => void;
+};

package/utils/internal/promise.js

@@ -0,0 +1,113 @@
+import { asReadable, computed, derived, equal, readable, writable } from '@amadeus-it-group/tansu';
+import { noop } from './func';
+export const promisePending = { status: 'pending' };
+const isThenable = (value) => {
+    // cf https://tc39.es/ecma262/#sec-promise-resolve-functions
+    const type = typeof value;
+    return (type === 'object' && value !== null) || type === 'function' ? typeof value.then === 'function' : false;
+};
+const createPromiseStateStore = (promise) => {
+    const store = writable(promisePending);
+    Promise.resolve(promise).then((value) => store.set({ status: 'fulfilled', value }), (reason) => store.set({ status: 'rejected', reason }));
+    return asReadable(store);
+};
+const promiseWeakMap = new WeakMap();
+export const promiseStateStore = (value) => {
+    if (!isThenable(value)) {
+        return readable({ status: 'fulfilled', value: value });
+    }
+    let response = promiseWeakMap.get(value);
+    if (!response) {
+        response = createPromiseStateStore(value);
+        promiseWeakMap.set(value, response);
+    }
+    return response;
+};
+const promiseStateStoreEqual = (a, b) => Object.is(a, b) ||
+    (a.status === b.status &&
+        (a.status !== 'fulfilled' || equal(a.value, b.value)) &&
+        (a.status !== 'rejected' || equal(a.reason, b.reason)));
+export const promiseStoreToPromiseStateStore = (promiseStore$) => computed(() => promiseStateStore(promiseStore$())(), { equal: promiseStateStoreEqual });
+export const promiseStateStoreToValueStore = (store$, initialValue, equal) => derived(store$, {
+    derive: (state, set) => {
+        if (state.status === 'fulfilled') {
+            set(state.value);
+        }
+    },
+    equal,
+}, initialValue);
+export const promiseStoreToValueStore = (promiseStore$, initialValue, equal) => promiseStateStoreToValueStore(promiseStoreToPromiseStateStore(promiseStore$), initialValue, equal);
+const truthyValue = (value) => !!value;
+export const promiseFromStore = (store, condition = truthyValue) => {
+    let resolve;
+    const promise = new Promise((r) => (resolve = r));
+    let unsubscribe = () => {
+        storeUnsubscribe();
+        unsubscribe = noop;
+    };
+    let storeUnsubscribe = noop;
+    storeUnsubscribe = store.subscribe((value) => {
+        if (condition(value)) {
+            resolve(value);
+            unsubscribe();
+        }
+    });
+    if (unsubscribe === noop) {
+        storeUnsubscribe();
+    }
+    return {
+        promise,
+        unsubscribe() {
+            unsubscribe();
+        },
+    };
+};
+export const promiseFromEvent = (element, event) => {
+    let resolve;
+    const promise = new Promise((r) => (resolve = r));
+    let unsubscribe = () => {
+        element.removeEventListener(event, eventListener);
+        unsubscribe = noop;
+    };
+    const eventListener = (event) => {
+        if (event.target === element) {
+            resolve(event);
+            unsubscribe();
+        }
+    };
+    element.addEventListener(event, eventListener);
+    return {
+        promise,
+        unsubscribe() {
+            unsubscribe();
+        },
+    };
+};
+export const promiseFromTimeout = (delay) => {
+    let timeout;
+    return {
+        promise: new Promise((r) => {
+            timeout = setTimeout(() => {
+                timeout = undefined;
+                r();
+            }, delay);
+        }),
+        unsubscribe() {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = undefined;
+            }
+        },
+    };
+};
+/**
+ * Utility method to create a promise with resolve
+ * @returns a promise with resolve
+ */
+export const promiseWithResolve = () => {
+    let resolve;
+    const promise = new Promise((r) => {
+        resolve = r;
+    });
+    return { promise, resolve: resolve };
+};

package/{modal → utils/internal}/scrollbars.js

@@ -1,4 +1,4 @@
-import { noop } from '../utils';
+import { noop } from './func';
 const internalRemoveScrollbars = () => {
     const scrollbarWidth = Math.abs(window.innerWidth - document.documentElement.clientWidth);
     const body = document.body;

package/utils/internal/textDirection.d.ts

@@ -0,0 +1 @@
+export declare const getTextDirection: (element: HTMLElement) => "rtl" | "ltr";

package/utils/internal/textDirection.js

@@ -0,0 +1 @@
+export const getTextDirection = (element) => getComputedStyle(element).direction;

package/utils/internal/traversal.d.ts

@@ -0,0 +1,54 @@
+interface TraversalFnOptions {
+    /**
+     * Remove symbol to return to remove the value
+     */
+    removeSymbol?: symbol;
+    /**
+     * index of the array, when looping on the elements
+     */
+    index?: number;
+}
+type TraversalFn = (key: string, value: any, options: TraversalFnOptions) => any;
+/**
+ * Creates a JSON walker function that can be used to traverse and transform
+ * the properties of a JSON object.
+ *
+ * @param fn - The callback function called for each property in the JSON object.
+ * @returns A function that takes a JSON object as input and applies the provided
+ * callback function to each property.
+ *
+ * @example
+ * ```typescript
+ * const json = {
+ *   name: 'John',
+ *   age: 30,
+ *   address: {
+ *     city: 'New York',
+ *     country: 'USA',
+ *   },
+ *   useless: '',
+ * };
+ *
+ * const transform = createTraversal((key, value, {removeSymbol}) => {
+ *   if (key === 'age') {
+ *     return value * 2; // Double the age
+ *   }
+ *   if (key === 'useless') {
+ * 	   return removeSymbol;
+ *   }
+ *   return value;
+ * });
+ *
+ * const transformedJson = transform(json);
+ * ```
+ */
+export declare function createTraversal(fn: TraversalFn): (json: any) => any;
+/**
+ * Utility method to create a promise with resolve
+ * @returns a promise with resolve
+ */
+export declare const promiseWithResolve: () => {
+    promise: Promise<void>;
+    resolve: (value: void | Promise<void>) => void;
+};
+export {};

package/utils/internal/traversal.js

@@ -0,0 +1,105 @@
+const removeSymbol = Symbol('remove');
+function _traversal(key, value, fn, index) {
+    const transformedValue = fn(key, value, { removeSymbol, index });
+    const type = Object.prototype.toString.call(transformedValue);
+    switch (type) {
+        case '[object Object]': {
+            const newJson = {};
+            const baseKey = key ? key + '.' : '';
+            for (const [name, objectValue] of Object.entries(transformedValue)) {
+                const newValue = _traversal(baseKey + name, objectValue, fn);
+                if (newValue !== removeSymbol) {
+                    newJson[name] = newValue;
+                }
+            }
+            return newJson;
+        }
+        case '[object Map]': {
+            const oldMap = transformedValue;
+            const newMap = new Map();
+            const baseKey = key ? key + '.' : '';
+            for (const [mapKey, objectValue] of Object.entries(oldMap)) {
+                const newValue = _traversal(baseKey + name, objectValue, fn);
+                if (newValue !== removeSymbol) {
+                    newMap.set(mapKey, newValue);
+                }
+            }
+            return newMap;
+        }
+        case '[object Array]': {
+            const ar = transformedValue;
+            const newArray = [];
+            const baseKey = (key ? key : '') + '[]';
+            for (let i = 0; i < ar.length; i++) {
+                const newValue = _traversal(baseKey, ar[i], fn, i);
+                if (newValue !== removeSymbol) {
+                    newArray.push(newValue);
+                }
+            }
+            return newArray;
+        }
+        case '[object Set]': {
+            const oldSet = transformedValue;
+            const newSet = new Set();
+            const baseKey = (key ? key : '') + '[]';
+            const ar = [...oldSet];
+            for (let i = 0; i < ar.length; i++) {
+                const newValue = _traversal(baseKey, ar[i], fn, i);
+                if (newValue !== removeSymbol) {
+                    newSet.add(newValue);
+                }
+            }
+            return newSet;
+        }
+        default:
+            break;
+    }
+    return transformedValue;
+}
+/**
+ * Creates a JSON walker function that can be used to traverse and transform
+ * the properties of a JSON object.
+ *
+ * @param fn - The callback function called for each property in the JSON object.
+ * @returns A function that takes a JSON object as input and applies the provided
+ * callback function to each property.
+ *
+ * @example
+ * ```typescript
+ * const json = {
+ *   name: 'John',
+ *   age: 30,
+ *   address: {
+ *     city: 'New York',
+ *     country: 'USA',
+ *   },
+ *   useless: '',
+ * };
+ *
+ * const transform = createTraversal((key, value, {removeSymbol}) => {
+ *   if (key === 'age') {
+ *     return value * 2; // Double the age
+ *   }
+ *   if (key === 'useless') {
+ * 	   return removeSymbol;
+ *   }
+ *   return value;
+ * });
+ *
+ * const transformedJson = transform(json);
+ * ```
+ */
+export function createTraversal(fn) {
+    return (json) => _traversal('', json, fn);
+}
+/**
+ * Utility method to create a promise with resolve
+ * @returns a promise with resolve
+ */
+export const promiseWithResolve = () => {
+    let resolve;
+    const promise = new Promise((r) => {
+        resolve = r;
+    });
+    return { promise, resolve: resolve };
+};

package/{services → utils}/stores.d.ts

@@ -1,16 +1,11 @@
-import type { ReadableSignal, StoreInput, StoreOptions, StoresInputValues, WritableSignal } from '@amadeus-it-group/tansu';
+import type { ReadableSignal, StoreInput, StoresInputValues, WritableSignal } from '@amadeus-it-group/tansu';
+import type { ConfigValidator, PropsConfig, ValuesOrReadableSignals, WritableWithDefaultOptions } from '../types';
 export type ToWritableSignal<P> = {
     [K in keyof P as `${K & string}$`]-?: WritableSignal<P[K], P[K] | undefined>;
 };
 export type ReadableSignals<T extends object> = {
     [K in keyof T]?: ReadableSignal<T[K] | undefined>;
 };
-export type ValuesOrReadableSignals<T extends object> = {
-    [K in keyof T]?: ReadableSignal<T[K] | undefined> | T[K];
-};
-export type ValuesOrWritableSignals<T extends object> = {
-    [K in keyof T]?: WritableSignal<T[K] | undefined> | T[K];
-};
 export type WithoutDollar<S extends `${string}$`> = S extends `${infer U}$` ? U : never;
 export type ValueOfStore<S extends ReadableSignal<any>> = S extends ReadableSignal<infer U> ? U : never;
 export type ToState<S extends {
@@ -51,18 +46,6 @@ export declare function createPatch<T extends object>(stores: ToWritableSignal<T
  * @returns the object with changed properties
  */
 export declare function findChangedProperties<T extends Record<string, any>>(obj1: Partial<T>, obj2: Partial<T>): Partial<T> | null;
-export declare const INVALID_VALUE: unique symbol;
-export type NormalizeValue<T> = (value: T) => T | typeof INVALID_VALUE;
-export interface WritableWithDefaultOptions<T> {
-    /**
-     * the normalize value function. should return the invalidValue symbol when the provided value is invalid
-     */
-    normalizeValue?: NormalizeValue<T>;
-    /**
-     * the equal function, allowing to compare two values. used to check if a previous and current values are equals.
-     */
-    equal?: StoreOptions<T>['equal'];
-}
 /**
  * Returns a writable store whose value is either its own value (when it is not undefined) or a default value
  * that comes either from the `config$` store (when it is not undefined) or from `defValue`.
@@ -78,9 +61,6 @@ export interface WritableWithDefaultOptions<T> {
  * @returns a writable store with the extra default value and normalization logic described above
  */
 export declare function writableWithDefault<T>(defValue: T, config$?: ReadableSignal<T | undefined>, options?: WritableWithDefaultOptions<T>, own$?: WritableSignal<T | undefined>): WritableSignal<T, T | undefined>;
-export type ConfigValidator<T extends object> = {
-    [K in keyof T]?: WritableWithDefaultOptions<T[K]>;
-};
 /**
  * Returns true if the provided argument is a store (ReadableSignal).
  * @param x - argument that is tested
@@ -156,22 +136,18 @@ export declare const writablesWithDefault: <T extends object>(defConfig: T, prop
  * ```
  */
 export declare const writablesForProps: <T extends object>(defConfig: T, propsConfig?: PropsConfig<T> | undefined, options?: { [K in keyof T]?: WritableWithDefaultOptions<T[K]> | undefined; } | undefined) => [ToWritableSignal<T>, <U extends Partial<T>>(storesValues?: void | U | undefined) => void];
-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.
-     * When the value of a property is undefined or invalid, the value from the config is used.
-     */
-    props?: ValuesOrWritableSignals<U>;
-    /**
-     * Either a store of objects containing, for each property, the default value,
-     * or an object containing, for each property, either a store containing the default value or the default value itself.
-     */
-    config?: ReadableSignal<Partial<U>> | ValuesOrReadableSignals<Partial<U>>;
-}
 export declare const stateStores: <A extends {
     [x: `${string}$`]: ReadableSignal<any>;
 }>(inputStores: A) => {
     state$: ReadableSignal<ToState<A>>;
     stores: { [key in `${string}$` & keyof A]: ReadableSignal<ValueOfStore<A[key]>>; };
 };
-export declare const bindableDerived: <T, U extends [WritableSignal<T, T>, ...StoreInput<any>[]]>(onChange$: ReadableSignal<(value: T) => void>, stores: U, adjustValue: (arg: StoresInputValues<U>) => T, equal?: (currentValue: T, newValue: T) => boolean) => ReadableSignal<T>;
+/**
+ * Creates a computed store that binds to multiple stores and triggers a callback when the value changes.
+ * @param onChange$ - A readable signal callback function to execute when the value changes.
+ * @param stores - An array of Svelte stores, with the main store at index 0.
+ * @param adjustValue - A function to adjust the value of the main store. By default, the value of the main store is returned.
+ * @param equal - A function to determine if two values are equal. Used to compare the ajusted value with the current one.
+ * @returns The derived store that reflects the combined state of the input stores.
+ */
+export declare const bindableDerived: <T, U extends [WritableSignal<T, T>, ...StoreInput<any>[]]>(onChange$: ReadableSignal<(value: T) => void>, stores: U, adjustValue?: (arg: StoresInputValues<U>) => T, equal?: (currentValue: T, newValue: T) => boolean) => ReadableSignal<T>;