@agnos-ui/core 0.2.0 → 0.3.1

package/utils/stores.js

@@ -1,298 +1,163 @@
-import { asReadable, asWritable, batch, computed, derived, equal as tansuDefaultEqual, 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.
- * Any key given to the patch function which is not in the original object will be ignored.
- *
- * @example
- *
- * ```typescript
- * const storeA$ = writable(1);
- * const storeB$ = writable(1);
- * const patch = createPatch({a: storeA$, b: storeB$});
- *
- * patch({a: 2}) // will perform storeA$.set(2)
- * patch({a: 2, b: 2}) // will perform storeA$.set(2) and storeB$.set(2) in the same batch.
- * patch({a: 2, c: 2}) // will perform storeA$.set(2), c is ignored.
- *
- * ```
- * @param stores - object of stores
- * @returns the patch function
- */
-export function createPatch(stores) {
-    return function (storesValues) {
-        batch(() => {
-            for (const [name, value] of Object.entries(storesValues ?? {})) {
-                stores[`${name}$`]?.set(value);
-            }
-        });
-    };
+import { batch, computed, asWritable, readable, writable, asReadable, get, derived, equal } from "@amadeus-it-group/tansu";
+import { INVALID_VALUE } from "../types.js";
+import { i as identity } from "../func-DR0n-ShK.js";
+function createPatch(stores) {
+  return function(storesValues) {
+    batch(() => {
+      var _a;
+      for (const [name, value] of Object.entries(storesValues ?? {})) {
+        (_a = stores[`${name}$`]) == null ? void 0 : _a.set(value);
+      }
+    });
+  };
 }
-/**
- * This utility function is designed to compare the first level of two objects.
- *
- * It returns a new object which has all the keys for which the values in `obj1`
- * and `obj2` are different, with the values from `obj2`, or null if objects
- * are identical.
- *
- * @param obj1 - First object
- * @param obj2 - Second object
- * @returns the object with changed properties
- */
-export function findChangedProperties(obj1, obj2) {
-    if (obj1 === obj2) {
-        return null;
-    }
-    let hasUpdate = false;
-    const changedValues = {};
-    const keys = 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;
-        }
+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;
+  }
+  return hasUpdate ? changedValues : null;
 }
-/**
- * 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`.
- * If a normalizeValue function is passed in the options, it is called to normalize non-undefined values coming
- * either from the `config$` store or from the `set` or `update` functions. If a value is invalid (i.e. normalizeValue
- * returns the `invalidValue` symbol), an error is logged on the console and it is either not set (if it comes from the
- * `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$ - 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), 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', value);
-            return defValue();
-        }
-        if (normalizedValue === undefined) {
-            return defValue();
-        }
-        return normalizedValue;
-    };
-    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;
-            }
-            value = normalizedValue;
-        }
-        own$.set(value);
-    });
-}
-/**
- * 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]);
-        }
+function writableWithDefault(defValue, config$ = readable(void 0), options = {}, own$ = writable(void 0)) {
+  const { normalizeValue = identity, equal: equal2 = Object.is } = options;
+  const getDefValue = () => defValue;
+  const callNormalizeValue = (value, defValue2 = getDefValue) => {
+    const normalizedValue = value === void 0 ? void 0 : normalizeValue(value);
+    if (normalizedValue === INVALID_VALUE) {
+      console.error("Not using invalid value", value);
+      return defValue2();
     }
-    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;
+    if (normalizedValue === void 0) {
+      return defValue2();
     }
-    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`,
- * with the exta `$` suffix (showing that they are stores).
- *
- * @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 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
- *
- * @example With a store
- * ```ts
- * const defConfig = {propA: 1};
- * const validation = {propA: {normalizeValue: value => +value}};
- * const config = writable({propA: 5});
- * const {propA$} = writablesWithDefault(defConfig, {config}, validation);
- * ```
- *
- * @example With an object containing a value and a store
- * ```ts
- * 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);
- * ```
- */
-export const writablesWithDefault = (defConfig, propsConfig, options) => {
-    const res = {};
-    const keys = Object.keys(defConfig);
-    const configStores = normalizeConfigStores(keys, propsConfig?.config);
-    const props = propsConfig?.props;
+    return normalizedValue;
+  };
+  const validatedDefConfig$ = computed(() => callNormalizeValue(config$()), { equal: equal2 });
+  const validatedOwnValue$ = computed(() => callNormalizeValue(own$(), validatedDefConfig$), { equal: equal2 });
+  return asWritable(validatedOwnValue$, (value) => {
+    if (value !== void 0) {
+      const normalizedValue = normalizeValue(value);
+      if (normalizedValue === 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 : readable(x);
+const toWritableStore = (x) => isStore(x) ? x : writable(x);
+const normalizeConfigStores = (keys, config) => {
+  const res = {};
+  if (config) {
+    const configIsStore = isStore(config);
     for (const key of keys) {
-        const propValue = props?.[key];
-        res[`${key}$`] = writableWithDefault(defConfig[key], configStores[key], options?.[key], toWritableStore(propValue));
+      res[key] = configIsStore ? computed(() => config()[key]) : toReadableStore(config[key]);
     }
-    return res;
+  }
+  return res;
 };
-/**
- * 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 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}),
- * and the second one containing the patch function (returned by {@link createPatch})
- *
- * @example With a store
- * ```ts
- * const defConfig = {propA: 1};
- * const validation = {propA: {normalizeValue: value => +value}};
- * const config$ = writable({propA: 5});
- * const [{propA$}, patch] = writablesForProps(defConfig, config$, validation);
- * ```
- *
- * @example With an object containing a value and a store
- * ```ts
- * const defConfig = {propA: 1, propB: 2};
- * const validation = {propA: {normalizeValue: value => +value}};
- * const config = {propA: 5, propB: writable(3)};
- * const [{propA$, propB$}, patch] = writablesForProps(defConfig, config, validation);
- * ```
- */
-export const writablesForProps = (defConfig, propsConfig, options) => {
-    const stores = writablesWithDefault(defConfig, propsConfig, options);
-    return [stores, createPatch(stores)];
+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 ? computed(() => config1Store() ?? config2Store()) : config1Store || config2Store;
+  }
+  return res;
 };
-/**
- * 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 = [];
-    const stores = {};
-    for (const key of Object.keys(inputStores)) {
-        if (key.endsWith('$')) {
-            const store = inputStores[key];
-            storesNames.push(key.substring(0, key.length - 1));
-            storesArray.push(store);
-            stores[key] = asReadable(store);
-        }
+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] = asReadable(store);
     }
-    return {
-        stores,
-        state$: computed(() => {
-            const values = storesArray.map(get);
-            const res = {};
-            storesNames.forEach((name, index) => {
-                res[name] = values[index];
-            });
-            return res;
-        }),
-    };
+  }
+  return {
+    stores,
+    state$: computed(() => {
+      const values = storesArray.map(get);
+      const res = {};
+      storesNames.forEach((name, index) => {
+        res[name] = values[index];
+      });
+      return res;
+    })
+  };
 };
-/**
- * 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 const bindableDerived = (onChange$, stores, adjustValue = (arg) => arg[0], equal = (currentValue, newValue) => newValue === currentValue) => {
-    let currentValue = stores[0]();
-    return asWritable(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,
-    }), stores[0].set.bind(stores[0]));
+const bindableDerived = (onChange$, stores, adjustValue = (arg) => arg[0], equal2 = (currentValue, newValue) => newValue === currentValue) => {
+  let currentValue = stores[0]();
+  return asWritable(
+    derived(stores, {
+      derive(values) {
+        const newValue = adjustValue(values);
+        const rectifiedValue = !equal2(values[0], newValue);
+        if (rectifiedValue) {
+          stores[0].set(newValue);
+        }
+        if (rectifiedValue || !equal2(currentValue, newValue)) {
+          currentValue = newValue;
+          onChange$()(newValue);
+        }
+        return newValue;
+      },
+      equal: equal2
+    }),
+    stores[0].set.bind(stores[0])
+  );
 };
-/**
- * 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 const bindableProp = (store$, onChange$, adjustValue = identity, equal = tansuDefaultEqual) => asWritable(computed(() => adjustValue(store$()), { equal }), (newValue) => {
+const bindableProp = (store$, onChange$, adjustValue = identity, equal$1 = equal) => asWritable(
+  computed(() => adjustValue(store$()), { equal: equal$1 }),
+  (newValue) => {
     const adjustedValue = adjustValue(newValue);
-    if (!equal(store$(), adjustedValue)) {
-        store$.set(adjustedValue);
-        onChange$()(adjustedValue);
+    if (!equal$1(store$(), adjustedValue)) {
+      store$.set(adjustedValue);
+      onChange$()(adjustedValue);
     }
-});
+  }
+);
+export {
+  bindableDerived,
+  bindableProp,
+  createPatch,
+  findChangedProperties,
+  isStore,
+  mergeConfigStores,
+  normalizeConfigStores,
+  stateStores,
+  toReadableStore,
+  toWritableStore,
+  writableWithDefault,
+  writablesForProps,
+  writablesWithDefault
+};

package/utils/writables.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils_writables = require("../writables-D46sFgGK.cjs");
+require("../types.cjs");
+exports.testToNormalizeValue = utils_writables.testToNormalizeValue;
+exports.typeArray = utils_writables.typeArray;
+exports.typeBoolean = utils_writables.typeBoolean;
+exports.typeBooleanOrNull = utils_writables.typeBooleanOrNull;
+exports.typeFunction = utils_writables.typeFunction;
+exports.typeHTMLElementOrNull = utils_writables.typeHTMLElementOrNull;
+exports.typeNumber = utils_writables.typeNumber;
+exports.typeNumberInRangeFactory = utils_writables.typeNumberInRangeFactory;
+exports.typeString = utils_writables.typeString;

package/utils/writables.js

@@ -1,72 +1,13 @@
-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]);
-        }
-    },
+import { t, h, c, d, f, g, a, b, e } from "../writables-DoU_XYTX.js";
+import "../types.js";
+export {
+  t as testToNormalizeValue,
+  h as typeArray,
+  c as typeBoolean,
+  d as typeBooleanOrNull,
+  f as typeFunction,
+  g as typeHTMLElementOrNull,
+  a as typeNumber,
+  b as typeNumberInRangeFactory,
+  e as typeString
 };

package/writables-D46sFgGK.cjs

@@ -0,0 +1,85 @@
+"use strict";
+const types = require("./types.cjs");
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value) && Number.isFinite(value);
+}
+function isBoolean(value) {
+  return value === true || value === false;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+const isArray = Array.isArray;
+function clamp(value, max, min = 0) {
+  return Math.max(Math.min(value, max), min);
+}
+const isHTMLElement = (value) => value instanceof HTMLElement;
+const allowNull = (isType) => (value) => value === null || isType(value);
+const testToNormalizeValue = (filter) => (value) => filter(value) ? value : types.INVALID_VALUE;
+const numberNormalizeFn = testToNormalizeValue(isNumber);
+const typeNumber = {
+  normalizeValue: numberNormalizeFn
+};
+function typeNumberInRangeFactory(min, max, options = {}) {
+  const { strict = false, useClamp = true } = options;
+  return {
+    normalizeValue: (value) => {
+      let normalizedNumber = numberNormalizeFn(value);
+      if (normalizedNumber !== types.INVALID_VALUE) {
+        if (!strict && useClamp) {
+          normalizedNumber = clamp(normalizedNumber, max, min);
+        }
+        if (normalizedNumber >= min && normalizedNumber <= max) {
+          if (!strict || normalizedNumber !== min && normalizedNumber !== max) {
+            return normalizedNumber;
+          }
+        }
+      }
+      return types.INVALID_VALUE;
+    }
+  };
+}
+const typeBoolean = {
+  normalizeValue: testToNormalizeValue(isBoolean)
+};
+const typeBooleanOrNull = {
+  normalizeValue: testToNormalizeValue(allowNull(isBoolean))
+};
+const typeString = {
+  normalizeValue: testToNormalizeValue(isString)
+};
+const typeFunction = {
+  normalizeValue: testToNormalizeValue(isFunction),
+  equal: Object.is
+};
+const typeHTMLElementOrNull = {
+  normalizeValue: testToNormalizeValue(allowNull(isHTMLElement)),
+  equal: Object.is
+};
+const typeArray = {
+  normalizeValue: testToNormalizeValue(isArray),
+  equal: (a, b) => {
+    if (a === b) {
+      return true;
+    } else {
+      if ((a == null ? void 0 : a.length) !== (b == null ? void 0 : b.length)) {
+        return false;
+      }
+      return a.every((val, index) => val === b[index]);
+    }
+  }
+};
+exports.clamp = clamp;
+exports.isNumber = isNumber;
+exports.testToNormalizeValue = testToNormalizeValue;
+exports.typeArray = typeArray;
+exports.typeBoolean = typeBoolean;
+exports.typeBooleanOrNull = typeBooleanOrNull;
+exports.typeFunction = typeFunction;
+exports.typeHTMLElementOrNull = typeHTMLElementOrNull;
+exports.typeNumber = typeNumber;
+exports.typeNumberInRangeFactory = typeNumberInRangeFactory;
+exports.typeString = typeString;