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

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

@@ -0,0 +1,172 @@
+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

@@ -0,0 +1,8 @@
+"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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,16 @@
+"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

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,103 @@
+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

@@ -0,0 +1,102 @@
+"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;

package/package.json

@@ -2,23 +2,34 @@
   "name": "@design-factory/angular",
   "description": "Amadeus design system Angular implementation",
   "license": "BSD-3-Clause",
-  "version": "21.0.4",
+  "version": "21.1.0-next.0",
+  "bundledDependencies": [
+    "@agnos-ui/core"
+  ],
   "dependencies": {
+    "@agnos-ui/core": "0.0.0",
     "tslib": "^2.0.0"
   },
   "peerDependencies": {
-    "@agnos-ui/angular-headless": "~0.10.0",
-    "@agnos-ui/core-bootstrap": "~0.10.0",
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0",
     "@angular/localize": "^21.0.0",
     "@angular/router": "^21.0.0",
-    "@design-factory/design-factory": "21.0.4",
-    "@design-factory/styles": "21.0.4"
+    "@design-factory/styles": "21.1.0-next.0",
+    "@amadeus-it-group/tansu": "^2.0.0",
+    "@floating-ui/dom": "^1.6.12",
+    "embla-carousel": "^8.5.2",
+    "esm-env": "^1.2.1"
   },
   "peerDependenciesMeta": {
     "@angular/router": {
       "optional": true
+    },
+    "@floating-ui/dom": {
+      "optional": true
+    },
+    "embla-carousel": {
+      "optional": true
     }
   },
   "schematics": "./schematics/collection.json",
@@ -46,7 +57,15 @@
     "./sidenav": {
       "types": "./types/design-factory-angular-sidenav.d.ts",
       "default": "./fesm2022/design-factory-angular-sidenav.mjs"
+    },
+    "./theme": {
+      "types": "./types/design-factory-angular-theme.d.ts",
+      "default": "./fesm2022/design-factory-angular-theme.mjs"
+    },
+    "./topnav": {
+      "types": "./types/design-factory-angular-topnav.d.ts",
+      "default": "./fesm2022/design-factory-angular-topnav.mjs"
     }
   },
   "sideEffects": false
-}
+}

package/schematics/collection.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "../../../node_modules/@angular-devkit/schematics/collection-schema.json",
+  "$schema": "../../../../node_modules/@angular-devkit/schematics/collection-schema.json",
   "schematics": {
     "ng-add": {
       "description": "Add design factory angular to the project and install dependencies.",