@design-factory/angular 21.1.0-next.0 → 21.1.0

package/node_modules/@agnos-ui/core/utils/stores.js

@@ -1,172 +0,0 @@
-import { readable, equal, asWritable, derived, computed, batch, asReadable, get, writable } from "@amadeus-it-group/tansu";
-import { INVALID_VALUE } from "../types.js";
-import { identity } from "./func.js";
-import { generateId } from "./id.js";
-function createPatch(stores) {
-  return function(storesValues) {
-    batch(() => {
-      for (const [name, value] of Object.entries(storesValues)) {
-        stores[`${name}$`]?.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$ = 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();
-    }
-    if (normalizedValue === void 0) {
-      return defValue2();
-    }
-    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) {
-      res[key] = configIsStore ? computed(() => config()[key]) : toReadableStore(config[key]);
-    }
-  }
-  return res;
-};
-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;
-};
-const writablesWithDefault = (defConfig, propsConfig, options) => {
-  const res = {};
-  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;
-};
-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;
-    })
-  };
-};
-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])
-  );
-};
-const bindableProp = (store$, onChange$, adjustValue = identity, equal$1 = equal) => asWritable(
-  computed(() => adjustValue(store$()), { equal: equal$1 }),
-  (newValue) => {
-    const adjustedValue = adjustValue(newValue);
-    if (!equal$1(store$(), adjustedValue)) {
-      store$.set(adjustedValue);
-      onChange$()(adjustedValue);
-    }
-  }
-);
-function idWithDefault(id$) {
-  const autoId$ = computed(() => generateId());
-  return computed(() => id$() || autoId$());
-}
-const true$ = readable(true);
-const false$ = readable(false);
-export {
-  bindableDerived,
-  bindableProp,
-  createPatch,
-  false$,
-  findChangedProperties,
-  idWithDefault,
-  isStore,
-  mergeConfigStores,
-  normalizeConfigStores,
-  stateStores,
-  toReadableStore,
-  toWritableStore,
-  true$,
-  writableWithDefault,
-  writablesForProps,
-  writablesWithDefault
-};

package/node_modules/@agnos-ui/core/utils/widget.cjs

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const types = require("../types.cjs");
-function createWidgetFactory(widgetName, factory) {
-  factory[types.FACTORY_WIDGET_NAME] = widgetName;
-  return factory;
-}
-exports.createWidgetFactory = createWidgetFactory;

package/node_modules/@agnos-ui/core/utils/widget.d.ts

@@ -1,11 +0,0 @@
-import type { PropsConfig, Widget, WidgetFactory, WidgetProps } from '../types';
-/**
- * Define a widget factory that can be linked with configuration through the provided widget name.
- *
- * @param widgetName - the widget name, used for configuration injection
- * @param factory - the widget factory function
- * @template W - The type of the widget
- * @template T - The type of the widget factory function. Useful when the widget factory has a generic.
- * @returns the widget factory
- */
-export declare function createWidgetFactory<W extends Widget, T extends (config?: PropsConfig<WidgetProps<W>>) => W = (config?: PropsConfig<WidgetProps<W>>) => W>(widgetName: string, factory: T): WidgetFactory<W, T>;

package/node_modules/@agnos-ui/core/utils/widget.js

@@ -1,8 +0,0 @@
-import { FACTORY_WIDGET_NAME } from "../types.js";
-function createWidgetFactory(widgetName, factory) {
-  factory[FACTORY_WIDGET_NAME] = widgetName;
-  return factory;
-}
-export {
-  createWidgetFactory
-};

package/node_modules/@agnos-ui/core/utils/writables.cjs

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const utils_writables = require("../writables-Dt68gADJ.cjs");
-require("../types.cjs");
-exports.createTypeEnum = utils_writables.createTypeEnum;
-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.typeNumberOrNull = utils_writables.typeNumberOrNull;
-exports.typeString = utils_writables.typeString;
-exports.typeStringOrNull = utils_writables.typeStringOrNull;

package/node_modules/@agnos-ui/core/utils/writables.d.ts

@@ -1,95 +0,0 @@
-import type { WritableWithDefaultOptions } from '../types';
-import { INVALID_VALUE } from '../types';
-/**
- * Check if a value respects a provided type guard.
- *
- * @template T - The type that the filter function validates.
- * @param filter - A function that takes a value and returns a boolean indicating
- *                 whether the value is of type T.
- * @returns A function that takes a value and returns the value if it passes the filter,
- *          otherwise returns `INVALID_VALUE`.
- */
-export declare const testToNormalizeValue: <T>(filter: (value: any) => value is T) => ((value: any) => T | typeof INVALID_VALUE);
-/**
- * A writable object with default options for handling numbers.
- */
-export declare const typeNumber: WritableWithDefaultOptions<number>;
-/**
- * Options for specifying the behavior of number range validation.
- */
-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>;
-/**
- * A writable object with default options for boolean values.
- *
- * This object provides a normalized way to handle boolean values
- * using the `WritableWithDefaultOptions` interface. The `normalizeValue`
- * function ensures that the value is properly validated and normalized
- * as a boolean.
- */
-export declare const typeBoolean: WritableWithDefaultOptions<boolean>;
-/**
- * A writable with default options that normalizes its value to a boolean or null.
- *
- * This writable uses a normalization function that allows null values and ensures
- * the value is a boolean.
- */
-export declare const typeBooleanOrNull: WritableWithDefaultOptions<boolean | null>;
-/**
- * A writable object with default options for string values.
- *
- * This object provides a normalized value for strings using the `testToNormalizeValue` function
- * with the `isString` validator.
- */
-export declare const typeString: WritableWithDefaultOptions<string>;
-/**
- * A writable with default options that normalizes its value to a string or null.
- *
- * This object provides a normalized value for strings using the `testToNormalizeValue` function
- * with the `isString` validator.
- */
-export declare const typeStringOrNull: WritableWithDefaultOptions<string | null>;
-/**
- * A writable with default options that normalizes its value to a number or null.
- *
- * This writable uses a normalization function that allows null values and ensures
- * the value is a boolean.
- */
-export declare const typeNumberOrNull: WritableWithDefaultOptions<number | null>;
-/**
- * A writable object that holds a function type with default options.
- */
-export declare const typeFunction: WritableWithDefaultOptions<(...args: any[]) => any>;
-/**
- * A writable object with default options for handling values of type `HTMLElement` or `null`.
- *
- * This object provides:
- * - `normalizeValue`: A function to normalize the value, ensuring it is either an `HTMLElement` or `null`.
- * - `equal`: A function to compare two values for equality using `Object.is`.
- */
-export declare const typeHTMLElementOrNull: WritableWithDefaultOptions<HTMLElement | null>;
-/**
- * A writable object with default options for handling arrays.
- */
-export declare const typeArray: WritableWithDefaultOptions<any[]>;
-/**
- * Build an enum normalizer
- * @template T - the enum type
- * @param enumList - list of enum values to check
- * @returns the enum normalizer
- */
-export declare function createTypeEnum<T>(enumList: T[]): WritableWithDefaultOptions<T>;

package/node_modules/@agnos-ui/core/utils/writables.js

@@ -1,16 +0,0 @@
-import { c, t, a, b, d, e, f, g, h, i, j, k } from "../writables-DYGjj5T3.js";
-import "../types.js";
-export {
-  c as createTypeEnum,
-  t as testToNormalizeValue,
-  a as typeArray,
-  b as typeBoolean,
-  d as typeBooleanOrNull,
-  e as typeFunction,
-  f as typeHTMLElementOrNull,
-  g as typeNumber,
-  h as typeNumberInRangeFactory,
-  i as typeNumberOrNull,
-  j as typeString,
-  k as typeStringOrNull
-};

package/node_modules/@agnos-ui/core/writables-DYGjj5T3.js

@@ -1,103 +0,0 @@
-import { INVALID_VALUE } from "./types.js";
-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);
-function isFromEnum(list) {
-  return (value) => list.includes(value);
-}
-const testToNormalizeValue = (filter) => (value) => filter(value) ? value : 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 !== 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;
-    }
-  };
-}
-const typeBoolean = {
-  normalizeValue: testToNormalizeValue(isBoolean)
-};
-const typeBooleanOrNull = {
-  normalizeValue: testToNormalizeValue(allowNull(isBoolean))
-};
-const typeString = {
-  normalizeValue: testToNormalizeValue(isString)
-};
-const typeStringOrNull = {
-  normalizeValue: testToNormalizeValue(allowNull(isString))
-};
-const typeNumberOrNull = {
-  normalizeValue: testToNormalizeValue(allowNull(isNumber))
-};
-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?.length !== b?.length) {
-        return false;
-      }
-      return a.every((val, index) => val === b[index]);
-    }
-  }
-};
-function createTypeEnum(enumList) {
-  return {
-    normalizeValue: testToNormalizeValue(isFromEnum(enumList))
-  };
-}
-export {
-  typeArray as a,
-  typeBoolean as b,
-  createTypeEnum as c,
-  typeBooleanOrNull as d,
-  typeFunction as e,
-  typeHTMLElementOrNull as f,
-  typeNumber as g,
-  typeNumberInRangeFactory as h,
-  typeNumberOrNull as i,
-  typeString as j,
-  typeStringOrNull as k,
-  clamp as l,
-  isNumber as m,
-  testToNormalizeValue as t
-};

package/node_modules/@agnos-ui/core/writables-Dt68gADJ.cjs

@@ -1,102 +0,0 @@
-"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);
-function isFromEnum(list) {
-  return (value) => list.includes(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 typeStringOrNull = {
-  normalizeValue: testToNormalizeValue(allowNull(isString))
-};
-const typeNumberOrNull = {
-  normalizeValue: testToNormalizeValue(allowNull(isNumber))
-};
-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?.length !== b?.length) {
-        return false;
-      }
-      return a.every((val, index) => val === b[index]);
-    }
-  }
-};
-function createTypeEnum(enumList) {
-  return {
-    normalizeValue: testToNormalizeValue(isFromEnum(enumList))
-  };
-}
-exports.clamp = clamp;
-exports.createTypeEnum = createTypeEnum;
-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.typeNumberOrNull = typeNumberOrNull;
-exports.typeString = typeString;
-exports.typeStringOrNull = typeStringOrNull;