@agnos-ui/core 0.0.1-alpha.0 → 0.0.1-alpha.10

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/{dist/lib/services → utils}/stores.d.ts

@@ -1,9 +1,10 @@
-import type { ReadableSignal, WritableSignal, StoreOptions, StoreInput, StoresInputValues } from '@amadeus-it-group/tansu';
-export type ToWritableSignal<P, V = P> = {
-    [K in keyof P & keyof V as `${K & string}$`]-?: WritableSignal<P[K], V[K] | undefined>;
+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 ValuesOrStores<T extends object> = {
-    [K in keyof T]?: ReadableSignal<T[K]> | T[K];
+export type ReadableSignals<T extends object> = {
+    [K in keyof T]?: ReadableSignal<T[K] | undefined>;
 };
 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;
@@ -32,7 +33,7 @@ export type ToState<S extends {
  * @param stores - object of stores
  * @returns the patch function
  */
-export declare function createPatch<T extends object, V extends object = T>(stores: ToWritableSignal<T, V>): <U extends Partial<T>>(storesValues?: void | U | undefined) => void;
+export declare function createPatch<T extends object>(stores: ToWritableSignal<T>): <U extends Partial<T>>(storesValues?: void | U | undefined) => void;
 /**
  * This utility function is designed to compare the first level of two objects.
  *
@@ -45,18 +46,6 @@ export declare function createPatch<T extends object, V extends object = T>(stor
  * @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, U = T> = (value: U) => T | typeof INVALID_VALUE;
-export interface WritableWithDefaultOptions<T, U = T> {
-    /**
-     * the normalize value function. should return the invalidValue symbol when the provided value is invalid
-     */
-    normalizeValue?: NormalizeValue<T, U>;
-    /**
-     * 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`.
@@ -66,14 +55,47 @@ export interface WritableWithDefaultOptions<T, U = T> {
  * `set` or `update` functions), or the `defValue` is used instead (if the invalid value comes from the `config$` store).
  *
  * @param defValue - Default value used when both the own value and the config$ value are undefined.
- * @param config$ - Default value used when the own value is undefined
+ * @param config$ - Store containing the default value used when the own value is undefined
  * @param options - Object which can contain the following optional functions: normalizeValue and equal
+ * @param own$ - Store containing the own value
  * @returns a writable store with the extra default value and normalization logic described above
  */
-export declare function writableWithDefault<T, U = T>(defValue: T, config$?: ReadableSignal<U | undefined>, { normalizeValue, equal }?: WritableWithDefaultOptions<T, U>): WritableSignal<T, U | undefined>;
-export type ConfigValidator<T extends object, U extends object = T> = {
-    [K in keyof T & keyof U]?: WritableWithDefaultOptions<T[K], U[K]>;
-};
+export declare function writableWithDefault<T>(defValue: T, config$?: ReadableSignal<T | undefined>, options?: WritableWithDefaultOptions<T>, own$?: WritableSignal<T | undefined>): WritableSignal<T, T | undefined>;
+/**
+ * Returns true if the provided argument is a store (ReadableSignal).
+ * @param x - argument that is tested
+ * @returns true if the argument is a store (ReadableSignal)
+ */
+export declare const isStore: (x: any) => x is ReadableSignal<any>;
+/**
+ * If the provided argument is already a store, it is returned as is, otherwise, a readable store is created with the provided argument as its initial value.
+ * @param x - either a store or a simple value
+ * @returns either x if x is already a store, or readable(x) otherwise
+ */
+export declare const toReadableStore: <T>(x: T | ReadableSignal<T>) => ReadableSignal<T>;
+/**
+ * If the provided argument is already a store, it is returned as is, otherwise, a writable store is created with the provided argument as its initial value.
+ * @param x - either a writable store or a simple value
+ * @returns either x if x is already a store, or writable(x) otherwise
+ */
+export declare const toWritableStore: <T>(x: T | WritableSignal<T, T>) => WritableSignal<T, T>;
+/**
+ * Extract and normalize config stores.
+ *
+ * @param keys - the keys of the stores to extract / normalize
+ * @param config - the config stores
+ * @returns the normalized config stores
+ */
+export declare const normalizeConfigStores: <T extends object>(keys: (keyof T)[], config?: ReadableSignal<Partial<T>> | ValuesOrReadableSignals<T> | undefined) => ReadableSignals<T>;
+/**
+ * Merge two stores configs into one
+ *
+ * @param keys - the keys of the stores to extract and merge from the two provided configs
+ * @param config1 - the first config
+ * @param config2 - the second config
+ * @returns the merged config
+ */
+export declare const mergeConfigStores: <T extends object>(keys: (keyof T)[], config1?: ReadableSignals<T> | undefined, config2?: ReadableSignals<T> | undefined) => ReadableSignals<T>;
 /**
  * Returns an object containing, for each property of `defConfig`, a corresponding writable with the normalization and default value logic
  * described in {@link writableWithDefault}. Keys in the returned object are the same as the ones present in `defConfig`,
@@ -81,8 +103,7 @@ export type ConfigValidator<T extends object, U extends object = T> = {
  *
  * @param defConfig - object containing, for each property, a default value to use in case `config$` does not provide the suitable default
  * value for that property
- * @param config - either a store of objects containing, for each property of `defConfig`, the default value or an object containing
- * for each property of `defConfig` either a store containing the default value or the default value itself
+ * @param propsConfig - object defining the config and props
  * @param options - object containing, for each property of `defConfig`, an optional object with the following optional functions: normalizeValue and equal
  * @returns an object containing writables
  *
@@ -90,8 +111,8 @@ export type ConfigValidator<T extends object, U extends object = T> = {
  * ```ts
  * const defConfig = {propA: 1};
  * const validation = {propA: {normalizeValue: value => +value}};
- * const config$ = writable({propA: 5});
- * const {propA$} = writablesWithDefault(defConfig, config$, validation);
+ * const config = writable({propA: 5});
+ * const {propA$} = writablesWithDefault(defConfig, {config}, validation);
  * ```
  *
  * @example With an object containing a value and a store
@@ -99,15 +120,15 @@ export type ConfigValidator<T extends object, U extends object = T> = {
  * const defConfig = {propA: 1, propB: 2};
  * const validation = {propA: {normalizeValue: value => +value}};
  * const config = {propA: 5, propB: writable(3)};
- * const {propA$, propB$} = writablesWithDefault(defConfig, config, validation);
+ * const {propA$, propB$} = writablesWithDefault(defConfig, {config}, validation);
  * ```
  */
-export declare const writablesWithDefault: <T extends object, U extends object = T>(defConfig: T, config?: PropsConfig<U> | undefined, options?: ConfigValidator<T, U> | undefined) => ToWritableSignal<T, U>;
+export declare const writablesWithDefault: <T extends object>(defConfig: T, propsConfig?: PropsConfig<T> | undefined, options?: ConfigValidator<T> | undefined) => ToWritableSignal<T>;
 /**
  * Shortcut for calling both {@link writablesWithDefault} and {@link createPatch} in one call.
  * @param defConfig - object containing, for each property, a default value to use in case `config` does not provide the suitable default
  * value for that property
- * @param config - either a store of objects containing, for each property of `defConfig`, the default value or an object containing
+ * @param propsConfig - either a store of objects containing, for each property of `defConfig`, the default value or an object containing
  * for each property of `defConfig` either a store containing the default value or the default value itself
  * @param options - object containing, for each property of `defConfig`, an optional object with the following optional functions: normalizeValue and equal
  * @returns an array with two items: the first one containing the writables (returned by {@link writablesWithDefault}),
@@ -129,12 +150,25 @@ export declare const writablesWithDefault: <T extends object, U extends object =
  * const [{propA$, propB$}, patch] = writablesForProps(defConfig, config, validation);
  * ```
  */
-export declare const writablesForProps: <T extends object, U extends object = T>(defConfig: T, config?: PropsConfig<U> | undefined, options?: { [K in keyof T & keyof U]?: WritableWithDefaultOptions<T[K], U[K]> | undefined; } | undefined) => [ToWritableSignal<T, U>, <U_1 extends Partial<T>>(storesValues?: void | U_1 | undefined) => void];
-export type PropsConfig<T extends object> = ReadableSignal<Partial<T>> | ValuesOrStores<T>;
+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];
+/**
+ * Using input stores, this function builds an object containing the stores as readable and a global state.
+ *
+ * @param inputStores - the input stores
+ * @returns the object containing the stores as readable and the global state
+ */
 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) => 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>;

package/{dist/lib/services → utils}/stores.js

@@ -1,5 +1,6 @@
-import { batch, computed, derived, get, readable, writable, asReadable } from '@amadeus-it-group/tansu';
-import { identity } from '../utils';
+import { asReadable, asWritable, batch, computed, derived, get, readable, writable } from '@amadeus-it-group/tansu';
+import { INVALID_VALUE } from '../types';
+import { identity } from './internal/func';
 /**
  *
  * Utility function designed to create a `patch` function related to the provided stores.
@@ -56,11 +57,6 @@ export function findChangedProperties(obj1, obj2) {
     }
     return hasUpdate ? changedValues : null;
 }
-const update = function (updater) {
-    this.set(updater(this()));
-};
-export const INVALID_VALUE = Symbol();
-/* eslint-disable jsdoc/check-param-names, jsdoc/require-param */
 /**
  * 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`.
@@ -70,41 +66,93 @@ export const INVALID_VALUE = Symbol();
  * `set` or `update` functions), or the `defValue` is used instead (if the invalid value comes from the `config$` store).
  *
  * @param defValue - Default value used when both the own value and the config$ value are undefined.
- * @param config$ - Default value used when the own value is undefined
+ * @param config$ - Store containing the default value used when the own value is undefined
  * @param options - Object which can contain the following optional functions: normalizeValue and equal
+ * @param own$ - Store containing the own value
  * @returns a writable store with the extra default value and normalization logic described above
  */
-export function writableWithDefault(defValue, config$ = readable(undefined), { normalizeValue = identity, equal = Object.is } = {}) {
-    const own$ = writable(undefined);
-    const validatedDefConfig$ = computed(() => {
-        const value = config$();
+export function writableWithDefault(defValue, config$ = readable(undefined), options = {}, own$ = writable(undefined)) {
+    const { normalizeValue = identity, equal = Object.is } = options;
+    const getDefValue = () => defValue;
+    const callNormalizeValue = (value, defValue = getDefValue) => {
         const normalizedValue = value === undefined ? undefined : normalizeValue(value);
         if (normalizedValue === INVALID_VALUE) {
-            console.error('Not using invalid value from default config', value);
-            return defValue;
+            console.error('Not using invalid value', value);
+            return defValue();
         }
         if (normalizedValue === undefined) {
-            return defValue;
+            return defValue();
         }
         return normalizedValue;
-    }, { equal });
-    return asReadable(computed(() => {
-        const ownValue = own$();
-        return ownValue !== undefined ? ownValue : validatedDefConfig$();
-    }, { equal }), {
-        set(value) {
-            const normalizedValue = value === undefined ? undefined : normalizeValue(value);
+    };
+    const validatedDefConfig$ = computed(() => callNormalizeValue(config$()), { equal });
+    const validatedOwnValue$ = computed(() => callNormalizeValue(own$(), validatedDefConfig$), { equal });
+    return asWritable(validatedOwnValue$, (value) => {
+        if (value !== undefined) {
+            const normalizedValue = normalizeValue(value);
             if (normalizedValue === INVALID_VALUE) {
                 console.error('Not setting invalid value', value);
+                return;
             }
-            else {
-                own$.set(normalizedValue);
-            }
-        },
-        update,
+            value = normalizedValue;
+        }
+        own$.set(value);
     });
 }
-const isStore = (x) => !!(x && typeof x === 'function' && 'subscribe' in x);
+/**
+ * Returns true if the provided argument is a store (ReadableSignal).
+ * @param x - argument that is tested
+ * @returns true if the argument is a store (ReadableSignal)
+ */
+export const isStore = (x) => !!(x && typeof x === 'function' && 'subscribe' in x);
+/**
+ * If the provided argument is already a store, it is returned as is, otherwise, a readable store is created with the provided argument as its initial value.
+ * @param x - either a store or a simple value
+ * @returns either x if x is already a store, or readable(x) otherwise
+ */
+export const toReadableStore = (x) => (isStore(x) ? x : readable(x));
+/**
+ * If the provided argument is already a store, it is returned as is, otherwise, a writable store is created with the provided argument as its initial value.
+ * @param x - either a writable store or a simple value
+ * @returns either x if x is already a store, or writable(x) otherwise
+ */
+export const toWritableStore = (x) => (isStore(x) ? x : writable(x));
+/**
+ * Extract and normalize config stores.
+ *
+ * @param keys - the keys of the stores to extract / normalize
+ * @param config - the config stores
+ * @returns the normalized config stores
+ */
+export const normalizeConfigStores = (keys, config) => {
+    const res = {};
+    if (config) {
+        const configIsStore = isStore(config);
+        for (const key of keys) {
+            res[key] = configIsStore
+                ? computed(() => config()[key])
+                : toReadableStore(config[key]);
+        }
+    }
+    return res;
+};
+/**
+ * Merge two stores configs into one
+ *
+ * @param keys - the keys of the stores to extract and merge from the two provided configs
+ * @param config1 - the first config
+ * @param config2 - the second config
+ * @returns the merged config
+ */
+export const mergeConfigStores = (keys, config1, config2) => {
+    const res = {};
+    for (const key of keys) {
+        const config1Store = config1?.[key];
+        const config2Store = config2?.[key];
+        res[key] = config1Store && config2Store ? computed(() => config1Store() ?? config2Store()) : config1Store || config2Store;
+    }
+    return res;
+};
 /**
  * Returns an object containing, for each property of `defConfig`, a corresponding writable with the normalization and default value logic
  * described in {@link writableWithDefault}. Keys in the returned object are the same as the ones present in `defConfig`,
@@ -112,8 +160,7 @@ const isStore = (x) => !!(x && typeof x === 'function' && 'subscribe' in x);
  *
  * @param defConfig - object containing, for each property, a default value to use in case `config$` does not provide the suitable default
  * value for that property
- * @param config - either a store of objects containing, for each property of `defConfig`, the default value or an object containing
- * for each property of `defConfig` either a store containing the default value or the default value itself
+ * @param propsConfig - object defining the config and props
  * @param options - object containing, for each property of `defConfig`, an optional object with the following optional functions: normalizeValue and equal
  * @returns an object containing writables
  *
@@ -121,8 +168,8 @@ const isStore = (x) => !!(x && typeof x === 'function' && 'subscribe' in x);
  * ```ts
  * const defConfig = {propA: 1};
  * const validation = {propA: {normalizeValue: value => +value}};
- * const config$ = writable({propA: 5});
- * const {propA$} = writablesWithDefault(defConfig, config$, validation);
+ * const config = writable({propA: 5});
+ * const {propA$} = writablesWithDefault(defConfig, {config}, validation);
  * ```
  *
  * @example With an object containing a value and a store
@@ -130,19 +177,17 @@ const isStore = (x) => !!(x && typeof x === 'function' && 'subscribe' in x);
  * const defConfig = {propA: 1, propB: 2};
  * const validation = {propA: {normalizeValue: value => +value}};
  * const config = {propA: 5, propB: writable(3)};
- * const {propA$, propB$} = writablesWithDefault(defConfig, config, validation);
+ * const {propA$, propB$} = writablesWithDefault(defConfig, {config}, validation);
  * ```
  */
-export const writablesWithDefault = (defConfig, config, options) => {
+export const writablesWithDefault = (defConfig, propsConfig, options) => {
     const res = {};
-    const configIsStore = isStore(config);
-    for (const key of Object.keys(defConfig)) {
-        let store = configIsStore ? computed(() => config()[key]) : undefined;
-        if (!configIsStore && config) {
-            const value = config[key];
-            store = isStore(value) ? value : readable(value);
-        }
-        res[`${key}$`] = writableWithDefault(defConfig[key], store, options?.[key]);
+    const keys = Object.keys(defConfig);
+    const configStores = normalizeConfigStores(keys, propsConfig?.config);
+    const props = propsConfig?.props;
+    for (const key of keys) {
+        const propValue = props?.[key];
+        res[`${key}$`] = writableWithDefault(defConfig[key], configStores[key], options?.[key], toWritableStore(propValue));
     }
     return res;
 };
@@ -150,7 +195,7 @@ export const writablesWithDefault = (defConfig, config, options) => {
  * Shortcut for calling both {@link writablesWithDefault} and {@link createPatch} in one call.
  * @param defConfig - object containing, for each property, a default value to use in case `config` does not provide the suitable default
  * value for that property
- * @param config - either a store of objects containing, for each property of `defConfig`, the default value or an object containing
+ * @param propsConfig - either a store of objects containing, for each property of `defConfig`, the default value or an object containing
  * for each property of `defConfig` either a store containing the default value or the default value itself
  * @param options - object containing, for each property of `defConfig`, an optional object with the following optional functions: normalizeValue and equal
  * @returns an array with two items: the first one containing the writables (returned by {@link writablesWithDefault}),
@@ -172,10 +217,16 @@ export const writablesWithDefault = (defConfig, config, options) => {
  * const [{propA$, propB$}, patch] = writablesForProps(defConfig, config, validation);
  * ```
  */
-export const writablesForProps = (defConfig, config, options) => {
-    const stores = writablesWithDefault(defConfig, config, options);
+export const writablesForProps = (defConfig, propsConfig, options) => {
+    const stores = writablesWithDefault(defConfig, propsConfig, options);
     return [stores, createPatch(stores)];
 };
+/**
+ * Using input stores, this function builds an object containing the stores as readable and a global state.
+ *
+ * @param inputStores - the input stores
+ * @returns the object containing the stores as readable and the global state
+ */
 export const stateStores = (inputStores) => {
     const storesNames = [];
     const storesArray = [];
@@ -200,20 +251,31 @@ export const stateStores = (inputStores) => {
         }),
     };
 };
-export const bindableDerived = (onChange$, stores, adjustValue) => {
+/**
+ * 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 const bindableDerived = (onChange$, stores, adjustValue = (arg) => arg[0], equal = (currentValue, newValue) => newValue === currentValue) => {
     let currentValue = stores[0]();
-    return derived(stores, (values) => {
-        const newValue = adjustValue(values);
-        const rectifiedValue = newValue !== values[0];
-        if (rectifiedValue) {
-            stores[0].set(newValue);
-        }
-        if (rectifiedValue || newValue !== currentValue) {
-            currentValue = newValue;
-            // TODO check if we should do this async to avoid issue
-            // with angular and react only when rectifiedValue is true?
-            onChange$()(newValue);
-        }
-        return newValue;
+    return derived(stores, {
+        derive(values) {
+            const newValue = adjustValue(values);
+            const rectifiedValue = !equal(values[0], newValue);
+            if (rectifiedValue) {
+                stores[0].set(newValue);
+            }
+            if (rectifiedValue || !equal(currentValue, newValue)) {
+                currentValue = newValue;
+                // TODO check if we should do this async to avoid issue
+                // with angular and react only when rectifiedValue is true?
+                onChange$()(newValue);
+            }
+            return newValue;
+        },
+        equal,
     });
 };

package/utils/writables.d.ts

@@ -0,0 +1,32 @@
+import type { WritableWithDefaultOptions } from '../types';
+import { INVALID_VALUE } from '../types';
+/**
+ * Check if a value respects a provided type guard.
+ *
+ * @param filter - the guard function
+ * @returns a function that takes a value as input, checks if it respects the type guard and returns `INVALID_VALUE` otherwise
+ */
+export declare const testToNormalizeValue: <T>(filter: (value: any) => value is T) => (value: any) => typeof INVALID_VALUE | T;
+export declare const typeNumber: WritableWithDefaultOptions<number>;
+export interface TypeNumberInRangeOptions {
+    /** If `true`, the range checking will be strict, excluding the minimum and maximum values. Default is `false`. */
+    strict?: boolean;
+    /** If `true`, values outside the range will be clamped to the minimum or maximum. Default is `true`. */
+    useClamp?: boolean;
+}
+/**
+ * Factory function for creating a type constraint for numbers within a specified range.
+ *
+ * @param min - The minimum value.
+ * @param max - The maximum value.
+ * @param options - Additional options to customize the behavior.
+ *
+ * @returns A type guard function that returns the clamp value or INVALID_VALUE depending on the provided options.
+ */
+export declare function typeNumberInRangeFactory(min: number, max: number, options?: TypeNumberInRangeOptions): WritableWithDefaultOptions<number>;
+export declare const typeBoolean: WritableWithDefaultOptions<boolean>;
+export declare const typeBooleanOrNull: WritableWithDefaultOptions<boolean | null>;
+export declare const typeString: WritableWithDefaultOptions<string>;
+export declare const typeFunction: WritableWithDefaultOptions<(...args: any[]) => any>;
+export declare const typeHTMLElementOrNull: WritableWithDefaultOptions<HTMLElement | null>;
+export declare const typeArray: WritableWithDefaultOptions<any[]>;

package/utils/writables.js

@@ -0,0 +1,72 @@
+import { allowNull, clamp, isArray, isBoolean, isFunction, isHTMLElement, isNumber, isString } from './internal/checks';
+import { INVALID_VALUE } from '../types';
+/**
+ * Check if a value respects a provided type guard.
+ *
+ * @param filter - the guard function
+ * @returns a function that takes a value as input, checks if it respects the type guard and returns `INVALID_VALUE` otherwise
+ */
+export const testToNormalizeValue = (filter) => (value) => filter(value) ? value : INVALID_VALUE;
+const numberNormalizeFn = testToNormalizeValue(isNumber);
+export const typeNumber = {
+    normalizeValue: numberNormalizeFn,
+};
+/**
+ * Factory function for creating a type constraint for numbers within a specified range.
+ *
+ * @param min - The minimum value.
+ * @param max - The maximum value.
+ * @param options - Additional options to customize the behavior.
+ *
+ * @returns A type guard function that returns the clamp value or INVALID_VALUE depending on the provided options.
+ */
+export function typeNumberInRangeFactory(min, max, options = {}) {
+    const { strict = false, useClamp = true } = options;
+    return {
+        normalizeValue: (value) => {
+            let normalizedNumber = numberNormalizeFn(value);
+            if (normalizedNumber !== INVALID_VALUE) {
+                if (!strict && useClamp) {
+                    normalizedNumber = clamp(normalizedNumber, max, min);
+                }
+                if (normalizedNumber >= min && normalizedNumber <= max) {
+                    if (!strict || (normalizedNumber !== min && normalizedNumber !== max)) {
+                        return normalizedNumber;
+                    }
+                }
+            }
+            return INVALID_VALUE;
+        },
+    };
+}
+export const typeBoolean = {
+    normalizeValue: testToNormalizeValue(isBoolean),
+};
+export const typeBooleanOrNull = {
+    normalizeValue: testToNormalizeValue(allowNull(isBoolean)),
+};
+export const typeString = {
+    normalizeValue: testToNormalizeValue(isString),
+};
+export const typeFunction = {
+    normalizeValue: testToNormalizeValue(isFunction),
+    equal: Object.is,
+};
+export const typeHTMLElementOrNull = {
+    normalizeValue: testToNormalizeValue(allowNull(isHTMLElement)),
+    equal: Object.is,
+};
+export const typeArray = {
+    normalizeValue: testToNormalizeValue(isArray),
+    equal: (a, b) => {
+        if (a === b) {
+            return true;
+        }
+        else {
+            if (a?.length !== b?.length) {
+                return false;
+            }
+            return a.every((val, index) => val === b[index]);
+        }
+    },
+};

package/dist/lib/index.d.ts

@@ -1,11 +0,0 @@
-export * from './types';
-export * from './select';
-export * from './services';
-export * from './transitions';
-export * from './rating';
-export * from './pagination';
-export * from './pagination.utils';
-export * from './config';
-export * from './modal/modal';
-export * from './alert';
-export * from './accordion';

package/dist/lib/index.js

@@ -1,11 +0,0 @@
-export * from './types';
-export * from './select';
-export * from './services';
-export * from './transitions';
-export * from './rating';
-export * from './pagination';
-export * from './pagination.utils';
-export * from './config';
-export * from './modal/modal';
-export * from './alert';
-export * from './accordion';