@agnos-ui/core 0.1.1 → 0.3.0

package/utils/stores.cjs

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const tansu = require("@amadeus-it-group/tansu");
+const types = require("../types.cjs");
+const func = require("../func-Qd3cD9a3.cjs");
+function createPatch(stores) {
+  return function(storesValues) {
+    tansu.batch(() => {
+      var _a;
+      for (const [name, value] of Object.entries(storesValues ?? {})) {
+        (_a = stores[`${name}$`]) == null ? void 0 : _a.set(value);
+      }
+    });
+  };
+}
+function findChangedProperties(obj1, obj2) {
+  if (obj1 === obj2) {
+    return null;
+  }
+  let hasUpdate = false;
+  const changedValues = {};
+  const keys = /* @__PURE__ */ new Set([...Object.keys(obj1), ...Object.keys(obj2)]);
+  for (const key of keys) {
+    const value = obj2[key];
+    if (obj1[key] !== value) {
+      changedValues[key] = value;
+      hasUpdate = true;
+    }
+  }
+  return hasUpdate ? changedValues : null;
+}
+function writableWithDefault(defValue, config$ = tansu.readable(void 0), options = {}, own$ = tansu.writable(void 0)) {
+  const { normalizeValue = func.identity, equal = Object.is } = options;
+  const getDefValue = () => defValue;
+  const callNormalizeValue = (value, defValue2 = getDefValue) => {
+    const normalizedValue = value === void 0 ? void 0 : normalizeValue(value);
+    if (normalizedValue === types.INVALID_VALUE) {
+      console.error("Not using invalid value", value);
+      return defValue2();
+    }
+    if (normalizedValue === void 0) {
+      return defValue2();
+    }
+    return normalizedValue;
+  };
+  const validatedDefConfig$ = tansu.computed(() => callNormalizeValue(config$()), { equal });
+  const validatedOwnValue$ = tansu.computed(() => callNormalizeValue(own$(), validatedDefConfig$), { equal });
+  return tansu.asWritable(validatedOwnValue$, (value) => {
+    if (value !== void 0) {
+      const normalizedValue = normalizeValue(value);
+      if (normalizedValue === types.INVALID_VALUE) {
+        console.error("Not setting invalid value", value);
+        return;
+      }
+      value = normalizedValue;
+    }
+    own$.set(value);
+  });
+}
+const isStore = (x) => !!(x && typeof x === "function" && "subscribe" in x);
+const toReadableStore = (x) => isStore(x) ? x : tansu.readable(x);
+const toWritableStore = (x) => isStore(x) ? x : tansu.writable(x);
+const normalizeConfigStores = (keys, config) => {
+  const res = {};
+  if (config) {
+    const configIsStore = isStore(config);
+    for (const key of keys) {
+      res[key] = configIsStore ? tansu.computed(() => config()[key]) : toReadableStore(config[key]);
+    }
+  }
+  return res;
+};
+const mergeConfigStores = (keys, config1, config2) => {
+  const res = {};
+  for (const key of keys) {
+    const config1Store = config1 == null ? void 0 : config1[key];
+    const config2Store = config2 == null ? void 0 : config2[key];
+    res[key] = config1Store && config2Store ? tansu.computed(() => config1Store() ?? config2Store()) : config1Store || config2Store;
+  }
+  return res;
+};
+const writablesWithDefault = (defConfig, propsConfig, options) => {
+  const res = {};
+  const keys = Object.keys(defConfig);
+  const configStores = normalizeConfigStores(keys, propsConfig == null ? void 0 : propsConfig.config);
+  const props = propsConfig == null ? void 0 : propsConfig.props;
+  for (const key of keys) {
+    const propValue = props == null ? void 0 : props[key];
+    res[`${key}$`] = writableWithDefault(defConfig[key], configStores[key], options == null ? void 0 : options[key], toWritableStore(propValue));
+  }
+  return res;
+};
+const writablesForProps = (defConfig, propsConfig, options) => {
+  const stores = writablesWithDefault(defConfig, propsConfig, options);
+  return [stores, createPatch(stores)];
+};
+const stateStores = (inputStores) => {
+  const storesNames = [];
+  const storesArray = [];
+  const stores = {};
+  for (const [key, store] of Object.entries(inputStores)) {
+    if (key.endsWith("$")) {
+      storesNames.push(key.substring(0, key.length - 1));
+      storesArray.push(store);
+      stores[key] = tansu.asReadable(store);
+    }
+  }
+  return {
+    stores,
+    state$: tansu.computed(() => {
+      const values = storesArray.map(tansu.get);
+      const res = {};
+      storesNames.forEach((name, index) => {
+        res[name] = values[index];
+      });
+      return res;
+    })
+  };
+};
+const bindableDerived = (onChange$, stores, adjustValue = (arg) => arg[0], equal = (currentValue, newValue) => newValue === currentValue) => {
+  let currentValue = stores[0]();
+  return tansu.asWritable(
+    tansu.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;
+          onChange$()(newValue);
+        }
+        return newValue;
+      },
+      equal
+    }),
+    stores[0].set.bind(stores[0])
+  );
+};
+const bindableProp = (store$, onChange$, adjustValue = func.identity, equal = tansu.equal) => tansu.asWritable(
+  tansu.computed(() => adjustValue(store$()), { equal }),
+  (newValue) => {
+    const adjustedValue = adjustValue(newValue);
+    if (!equal(store$(), adjustedValue)) {
+      store$.set(adjustedValue);
+      onChange$()(adjustedValue);
+    }
+  }
+);
+exports.bindableDerived = bindableDerived;
+exports.bindableProp = bindableProp;
+exports.createPatch = createPatch;
+exports.findChangedProperties = findChangedProperties;
+exports.isStore = isStore;
+exports.mergeConfigStores = mergeConfigStores;
+exports.normalizeConfigStores = normalizeConfigStores;
+exports.stateStores = stateStores;
+exports.toReadableStore = toReadableStore;
+exports.toWritableStore = toWritableStore;
+exports.writableWithDefault = writableWithDefault;
+exports.writablesForProps = writablesForProps;
+exports.writablesWithDefault = writablesWithDefault;

package/utils/stores.d.ts

@@ -7,12 +7,6 @@ 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;
-export type ToState<S extends {
-    [K in keyof S & `${string}$`]: ReadableSignal<any>;
-}> = {
-    [K in keyof S & `${string}$` as WithoutDollar<K>]: ValueOfStore<S[K]>;
-};
 /**
  *
  * Utility function designed to create a `patch` function related to the provided stores.
@@ -72,13 +66,13 @@ export declare const isStore: (x: any) => x is ReadableSignal<any>;
  * @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>;
+export declare const toReadableStore: <T>(x: ReadableSignal<T> | 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 toWritableStore: <T>(x: WritableSignal<T> | T) => WritableSignal<T, T>;
 /**
  * Extract and normalize config stores.
  *
@@ -86,7 +80,7 @@ export declare const toWritableStore: <T>(x: T | WritableSignal<T, T>) => Writab
  * @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>;
+export declare const normalizeConfigStores: <T extends object>(keys: (keyof T)[], config?: ReadableSignal<Partial<T>> | ValuesOrReadableSignals<T>) => ReadableSignals<T>;
 /**
  * Merge two stores configs into one
  *
@@ -95,7 +89,7 @@ export declare const normalizeConfigStores: <T extends object>(keys: (keyof T)[]
  * @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>;
+export declare const mergeConfigStores: <T extends object>(keys: (keyof T)[], config1?: ReadableSignals<T>, config2?: ReadableSignals<T>) => 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`,
@@ -123,7 +117,7 @@ export declare const mergeConfigStores: <T extends object>(keys: (keyof T)[], co
  * const {propA$, propB$} = writablesWithDefault(defConfig, {config}, validation);
  * ```
  */
-export declare const writablesWithDefault: <T extends object>(defConfig: T, propsConfig?: PropsConfig<T> | undefined, options?: ConfigValidator<T> | undefined) => ToWritableSignal<T>;
+export declare const writablesWithDefault: <T extends object>(defConfig: T, propsConfig?: PropsConfig<T>, options?: ConfigValidator<T>) => 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
@@ -150,25 +144,34 @@ export declare const writablesWithDefault: <T extends object>(defConfig: T, prop
  * const [{propA$, propB$}, patch] = writablesForProps(defConfig, config, validation);
  * ```
  */
-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 declare const writablesForProps: <T extends object>(defConfig: T, propsConfig?: PropsConfig<T>, options?: { [K in keyof T]?: WritableWithDefaultOptions<T[K]> | undefined; } | undefined) => [ToWritableSignal<T>, ReturnType<typeof createPatch<T>>];
 /**
  * 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 stateStores: <A extends object>(inputStores: { [K in keyof A as `${K & string}$`]: ReadableSignal<any>; }) => {
+    state$: ReadableSignal<A>;
+    stores: { [K_1 in keyof A as `${K_1 & string}$`]: ReadableSignal<A[K_1]>; };
 };
 /**
- * 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.
+ * Creates a derived store that binds to multiple stores and triggers a callback when the value changes for any reason.
+ * @param onChange$ - A readable signal containing a 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>;
+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) => WritableSignal<T, T>;
+/**
+ * Creates a computed store that contains the adjusted value of the given store and that triggers a callback when the value changes from the set or update
+ * method of the returned writable store.
+ * @param store$ - store to be bound
+ * @param onChange$ - A readable signal containing a callback function to execute when the value changes from the set or update method of the returned writable store.
+ * @param adjustValue - A function to adjust the value of the store, called in a reactive context each time the value changes or any called dependency changes.
+ * By default, the value of store$ is returned.
+ * @param equal - A function to determine if two values are equal.
+ * @returns A writable store that contains the adjusted value of the given store, with the set or update functions that trigger the onChange$ callback.
+ */
+export declare const bindableProp: <T>(store$: WritableSignal<T, T | undefined>, onChange$: ReadableSignal<(newValue: T) => void>, adjustValue?: (value: T) => T, equal?: (a: T, b: T) => boolean) => WritableSignal<T, T>;