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

package/{dist/lib/services → services}/stores.d.ts

@@ -1,9 +1,15 @@
-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, StoreOptions, StoresInputValues, WritableSignal } from '@amadeus-it-group/tansu';
+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 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;
@@ -32,7 +38,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.
  *
@@ -46,12 +52,12 @@ export declare function createPatch<T extends object, V extends object = T>(stor
  */
 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> {
+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, U>;
+    normalizeValue?: NormalizeValue<T>;
     /**
      * the equal function, allowing to compare two values. used to check if a previous and current values are equals.
      */
@@ -66,14 +72,35 @@ 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>;
+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
+ * @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>;
+export declare const normalizeConfigStores: <T extends object>(keys: (keyof T)[], config?: ReadableSignal<Partial<T>> | ValuesOrReadableSignals<T> | undefined) => ReadableSignals<T>;
+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 +108,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 +116,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 +125,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 +155,23 @@ 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];
+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) => ReadableSignal<T>;
+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 → services}/stores.js

@@ -1,4 +1,4 @@
-import { batch, computed, derived, get, readable, writable, asReadable } from '@amadeus-it-group/tansu';
+import { asReadable, batch, computed, derived, get, readable, writable } from '@amadeus-it-group/tansu';
 import { identity } from '../utils';
 /**
  *
@@ -60,7 +60,6 @@ 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 +69,81 @@ 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 }), {
+    };
+    const validatedDefConfig$ = computed(() => callNormalizeValue(config$()), { equal });
+    const validatedOwnValue$ = computed(() => callNormalizeValue(own$(), validatedDefConfig$), { equal });
+    return asReadable(validatedOwnValue$, {
         set(value) {
-            const normalizedValue = value === undefined ? undefined : normalizeValue(value);
-            if (normalizedValue === INVALID_VALUE) {
-                console.error('Not setting invalid value', value);
-            }
-            else {
-                own$.set(normalizedValue);
+            if (value !== undefined) {
+                const normalizedValue = normalizeValue(value);
+                if (normalizedValue === INVALID_VALUE) {
+                    console.error('Not setting invalid value', value);
+                    return;
+                }
+                value = normalizedValue;
             }
+            own$.set(value);
         },
         update,
     });
 }
-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));
+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;
+};
+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 +151,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 +159,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 +168,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 +186,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,8 +208,8 @@ 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)];
 };
 export const stateStores = (inputStores) => {
@@ -200,20 +236,23 @@ export const stateStores = (inputStores) => {
         }),
     };
 };
-export const bindableDerived = (onChange$, stores, adjustValue) => {
+export const bindableDerived = (onChange$, stores, adjustValue, 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/{dist/lib/services → services}/writables.d.ts

@@ -3,5 +3,6 @@ import { INVALID_VALUE } from './stores';
 export declare const testToNormalizeValue: <T>(filter: (value: T) => boolean) => (value: T) => typeof INVALID_VALUE | T;
 export declare const typeNumber: WritableWithDefaultOptions<number>;
 export declare const typeBoolean: WritableWithDefaultOptions<boolean>;
-export declare const typeString: WritableWithDefaultOptions<string, any>;
+export declare const typeString: WritableWithDefaultOptions<string>;
 export declare const typeFunction: WritableWithDefaultOptions<(...args: any[]) => any>;
+export declare const typeArray: WritableWithDefaultOptions<any[]>;

package/{dist/lib/services → services}/writables.js

@@ -1,4 +1,4 @@
-import { isBoolean, isFunction, isNumber, isString } from './checks';
+import { isArray, isBoolean, isFunction, isNumber, isString } from './checks';
 import { INVALID_VALUE } from './stores';
 export const testToNormalizeValue = (filter) => (value) => filter(value) ? value : INVALID_VALUE;
 export const typeNumber = {
@@ -14,3 +14,17 @@ export const typeFunction = {
     normalizeValue: testToNormalizeValue(isFunction),
     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/tsdoc-metadata.json

@@ -1,11 +0,0 @@
-// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
-// It should be published with your NPM package.  It should not be tracked by Git.
-{
-  "tsdocVersion": "0.12",
-  "toolPackages": [
-    {
-      "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.36.4"
-    }
-  ]
-}