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

package/node_modules/@agnos-ui/core/tree-HwcvZ0_p.js

@@ -1,229 +0,0 @@
-import { writable, computed, readable } from "@amadeus-it-group/tansu";
-import { createNavManager } from "./services/navManager.js";
-import { s as mergeDirectives, d as browserDirective, g as createAttributesDirective, b as bindDirective } from "./directive-Bsreu2z1.js";
-import { noop } from "./utils/func.js";
-import { writablesForProps, stateStores, true$ } from "./utils/stores.js";
-import { e as typeFunction, a as typeArray, j as typeString } from "./writables-DYGjj5T3.js";
-import { createWidgetFactory } from "./utils/widget.js";
-function getTreeDefaultConfig() {
-  return {
-    ...defaultTreeConfig
-  };
-}
-const defaultTreeConfig = {
-  className: "",
-  nodes: [],
-  onExpandToggle: noop,
-  navSelector: (node) => node.querySelectorAll("button"),
-  ariaLabelToggleFn: (label) => `Toggle ${label}`
-};
-const configValidator = {
-  className: typeString,
-  nodes: typeArray,
-  onExpandToggle: typeFunction,
-  navSelector: typeFunction,
-  ariaLabelToggleFn: typeFunction
-};
-const createTree = createWidgetFactory("tree", (config) => {
-  const [{ nodes$, onExpandToggle$, navSelector$, ariaLabelToggleFn$, ...stateProps }, patch] = writablesForProps(
-    defaultTreeConfig,
-    config,
-    configValidator
-  );
-  const treeMap = /* @__PURE__ */ new Map();
-  const _expandedMap = {
-    get(item) {
-      return item.isExpanded;
-    }
-  };
-  const _toggleChange$ = writable({});
-  const expandedMap$ = computed(() => {
-    normalizedNodes$();
-    _toggleChange$();
-    return _expandedMap;
-  });
-  const {
-    elementsInDomOrder$,
-    directive: navDirective,
-    refreshElements,
-    focusIndex,
-    focusPrevious,
-    focusNext,
-    focusFirst,
-    focusLast
-  } = createNavManager();
-  const navManagerConfig$ = computed(() => ({
-    keys: {
-      ArrowUp: focusPrevious,
-      ArrowDown: focusNext,
-      Home: focusFirst,
-      End: focusLast
-    },
-    selector: navSelector$()
-  }));
-  const traverseTree = (node, level, parent) => {
-    const copyNode = {
-      ...node,
-      ariaLabel: node.ariaLabel ?? node.label,
-      level,
-      children: [],
-      isExpanded: node.children?.length ? node.isExpanded ?? false : void 0
-    };
-    treeMap.set(copyNode, {
-      parent
-    });
-    if (node.children) {
-      copyNode.children = node.children.map((child) => traverseTree(child, level + 1, copyNode));
-    }
-    return copyNode;
-  };
-  const normalizedNodes$ = computed(() => {
-    treeMap.clear();
-    return nodes$().map((node) => traverseTree(node, 0, void 0));
-  });
-  const _lastFocusedTreeItem$ = writable(
-    normalizedNodes$().find((node) => node.isExpanded !== void 0)
-  );
-  const getTreeItemInfo = (item) => {
-    const treeItem = treeMap.get(item);
-    if (!treeItem) {
-      console.error(`Node ${item.label} doesn't exist in the map`);
-    }
-    return treeItem;
-  };
-  const treeItemElementDirective = browserDirective(
-    (toggleItem, args) => {
-      let treeItemInfo;
-      const destroy = () => {
-        if (treeItemInfo && treeItemInfo.htmlElement === toggleItem) {
-          treeItemInfo.htmlElement = void 0;
-        }
-        treeItemInfo = void 0;
-      };
-      const update = (args2) => {
-        destroy();
-        treeItemInfo = getTreeItemInfo(args2.item);
-        if (treeItemInfo) {
-          if (treeItemInfo.htmlElement) {
-            console.warn(`The tree item directive should be used once per element`);
-          }
-          treeItemInfo.htmlElement = toggleItem;
-        }
-      };
-      update(args);
-      return {
-        update,
-        destroy
-      };
-    }
-  );
-  const focusElementIfExists = (itemToFocus) => {
-    if (itemToFocus) {
-      const mapItemHtml = getTreeItemInfo(itemToFocus)?.htmlElement;
-      if (mapItemHtml) {
-        const index = elementsInDomOrder$().indexOf(mapItemHtml);
-        focusIndex(index, 0);
-      }
-    }
-  };
-  const itemToggleAttributesDirective = createAttributesDirective(
-    (treeItemContext$) => ({
-      events: {
-        focus: () => {
-          const { item } = treeItemContext$();
-          _lastFocusedTreeItem$.set(item);
-        },
-        click: () => {
-          const { item } = treeItemContext$();
-          toggleExpanded(item);
-        },
-        keydown: (event) => {
-          const { key } = event;
-          const { item } = treeItemContext$();
-          const isExpanded = item.isExpanded;
-          refreshElements();
-          switch (key) {
-            case "Enter":
-            case " ":
-              toggleExpanded(item);
-              break;
-            case "ArrowLeft":
-              if (isExpanded) {
-                toggleExpanded(item);
-              } else {
-                focusElementIfExists(getTreeItemInfo(item)?.parent);
-              }
-              break;
-            case "ArrowRight":
-              if (!isExpanded) {
-                toggleExpanded(item);
-              } else {
-                focusElementIfExists(item.children?.[0]);
-              }
-              break;
-            default:
-              return;
-          }
-          event.preventDefault();
-          event.stopPropagation();
-        }
-      },
-      attributes: {
-        "aria-label": computed(() => {
-          const { item } = treeItemContext$();
-          return ariaLabelToggleFn$()(item.ariaLabel);
-        }),
-        tabindex: computed(() => {
-          const { item } = treeItemContext$();
-          return item === _lastFocusedTreeItem$() ? "0" : "-1";
-        }),
-        type: readable("button")
-      },
-      classNames: {
-        "au-tree-expand-icon": true$,
-        "au-tree-expand-icon-expanded": computed(() => {
-          _toggleChange$();
-          const { item } = treeItemContext$();
-          return item.isExpanded ?? false;
-        })
-      }
-    })
-  );
-  const toggleExpanded = (node) => {
-    const treeItemInfo = getTreeItemInfo(node);
-    if (treeItemInfo === void 0 || node.isExpanded === void 0) {
-      return;
-    }
-    node.isExpanded = !node.isExpanded;
-    _toggleChange$.set({});
-    onExpandToggle$()(node);
-  };
-  const widget = {
-    ...stateStores({ normalizedNodes$, expandedMap$, ...stateProps }),
-    patch,
-    api: {},
-    directives: {
-      navigationDirective: bindDirective(navDirective, navManagerConfig$),
-      itemToggleDirective: mergeDirectives(treeItemElementDirective, itemToggleAttributesDirective),
-      itemAttributesDirective: createAttributesDirective(
-        (treeItemContext$) => ({
-          attributes: {
-            role: readable("treeitem"),
-            "aria-selected": readable("false"),
-            // TODO: adapt aria-selected to the actual selected state
-            "aria-expanded": computed(() => {
-              const { item } = treeItemContext$();
-              _toggleChange$();
-              return item.isExpanded?.toString();
-            })
-          }
-        })
-      )
-    }
-  };
-  return widget;
-});
-export {
-  createTree as c,
-  getTreeDefaultConfig as g
-};

package/node_modules/@agnos-ui/core/types.cjs

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const FACTORY_WIDGET_NAME = /* @__PURE__ */ Symbol();
-const INVALID_VALUE = /* @__PURE__ */ Symbol();
-exports.FACTORY_WIDGET_NAME = FACTORY_WIDGET_NAME;
-exports.INVALID_VALUE = INVALID_VALUE;

package/node_modules/@agnos-ui/core/types.d.ts

@@ -1,246 +0,0 @@
-import type { ReadableSignal, StoreOptions, SubscribableStore, WritableSignal } from '@amadeus-it-group/tansu';
-/**
- * A type that maps each property of an object type `T` to either a `ReadableSignal` of that property type or the property type itself.
- *
- * @template T - The object type whose properties are being mapped.
- */
-export type ValuesOrReadableSignals<T extends object> = {
-    [K in keyof T]?: ReadableSignal<T[K] | undefined> | T[K];
-};
-/**
- * A type that maps the properties of an object type `T` to either a `WritableSignal` of the property type or the property type itself.
- *
- * @template T - The object type whose properties are being mapped.
- */
-export type ValuesOrWritableSignals<T extends object> = {
-    [K in keyof T]?: WritableSignal<T[K] | undefined> | T[K];
-};
-/**
- * Interface representing the configuration for properties.
- *
- * @template U - An object type representing the properties.
- */
-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>>;
-}
-/**
- * Represents a generic widget with reactive state, stores, and various functionalities.
- *
- * @template Props - The type of the properties that can be passed to the widget.
- * @template State - The type of the state managed by the widget.
- * @template Api - The type of the API functions available for interacting with the widget.
- * @template Actions - The type of the action handlers for user interactions.
- * @template Directives - The type of the directives used in the widget's template.
- */
-export interface Widget<Props extends object = object, State extends object = object, Api extends object = object, Directives extends object = object> {
-    /**
-     * the reactive state of the widget, combining all the values served by the stores
-     */
-    state$: ReadableSignal<State>;
-    /**
-     * the different stores of the widget, all reactive
-     */
-    stores: {
-        [K in keyof State as `${K & string}$`]: ReadableSignal<State[K]>;
-    };
-    /**
-     * Modify the parameter values, and recalculate the stores accordingly
-     */
-    patch(parameters: Partial<Props>): void;
-    /**
-     * directives to be used on html elements in the template of the widget
-     */
-    directives: Directives;
-    /**
-     * all the api functions to interact with the widget
-     */
-    api: Api;
-}
-/**
- * Extracts the state type from a widget type that contains a `state$` property.
- *
- * @template T - A type that extends an object with a `state$` property of type `SubscribableStore<any>`.
- * @returns The type of the state contained within the `state$` property if it extends an object, otherwise `never`.
- */
-export type WidgetState<T extends {
-    state$: SubscribableStore<any>;
-}> = T extends {
-    state$: SubscribableStore<infer U extends object>;
-} ? U : never;
-/**
- * Extracts the type of the argument expected by the `patch` method of a given type `T`.
- *
- * This utility type takes a generic type `T` which must have a `patch` method. The `patch` method
- * should accept an argument that is a partial of some object type `U`. If `T` meets this condition,
- * `WidgetProps` will resolve to the type `U`. Otherwise, it will resolve to `never`.
- *
- * @template T - A type that includes a `patch` method accepting a partial object.
- */
-export type WidgetProps<T extends {
-    patch: (arg: any) => void;
-}> = T extends {
-    patch: (arg: Partial<infer U extends object>) => void;
-} ? U : never;
-/**
- * A unique symbol representing a widget factory widget name.
- */
-export declare const FACTORY_WIDGET_NAME: unique symbol;
-/**
- * A factory function type for creating instances of a widget.
- *
- * @template W - The type of the widget that extends the base Widget type.
- * @template T - The type of the factory function that creates the widget. Useful when the factory function has a generic
- * @param props - Optional configuration properties for the widget.
- * @returns An instance of the widget.
- */
-export type WidgetFactory<W extends Widget, T extends (props?: PropsConfig<WidgetProps<W>>) => W = (props?: PropsConfig<WidgetProps<W>>) => W> = T & {
-    [FACTORY_WIDGET_NAME]?: string;
-};
-/**
- * Represents a server-side rendered HTML element with limited functionality.
- *
- * This interface extends a subset of the {@link HTMLElement} interface, providing
- * methods to set and remove attributes, manipulate the element's classes, and
- * partially manipulate the element's style.
- *
- * It inherits the {@link https://developer.mozilla.org/docs/Web/API/Element/setAttribute | setAttribute} and {@link https://developer.mozilla.org/docs/Web/API/Element/getAttribute | getAttribute} methods from the {@link HTMLElement} interface.
- *
- */
-export interface SSRHTMLElement extends Pick<HTMLElement, 'setAttribute' | 'removeAttribute'> {
-    /**
-     * Object allowing to manipulate the classes of the element.
-     */
-    classList: Pick<HTMLElement['classList'], 'add' | 'remove' | 'toggle'>;
-    /**
-     * Object allowing to manipulate the style of the element.
-     */
-    style: Partial<Record<StyleKeyCamelCase | StyleKeyKebabCase, StyleValue>> & Pick<HTMLElement['style'], 'setProperty' | 'removeProperty'>;
-}
-/**
- * Represents a directive function that can be applied to an SSRHTMLElement.
- *
- * @template T - The type of the arguments passed to the directive.
- * @template U - The type of the SSRHTMLElement, defaults to SSRHTMLElement.
- *
- * @param node - The SSRHTMLElement to which the directive is applied.
- * @param args - The arguments passed to the directive.
- *
- * @returns An optional object that may contain:
- * - `update`: A function to update the directive with new arguments.
- * - `destroy`: A function to clean up when the directive is no longer needed.
- */
-export type Directive<T = void, U extends SSRHTMLElement = SSRHTMLElement> = (node: U, args: T) => void | {
-    update?: (args: T) => void;
-    destroy?: () => void;
-};
-/**
- * Represents a tuple containing a directive and its associated parameter.
- *
- * @template T - The type of the parameter associated with the directive.
- * @template U - The type of the SSRHTMLElement, defaults to SSRHTMLElement.
- */
-export type DirectiveAndParam<T, U extends SSRHTMLElement = SSRHTMLElement> = [Directive<T, U>, T];
-/**
- * Represents a mapping of directives and their optional parameters.
- *
- * @template T - An array type representing the parameters for the directives.
- * @template U - The type of the SSR HTML element, defaults to `SSRHTMLElement`.
- */
-export type DirectivesAndOptParam<T extends any[], U extends SSRHTMLElement = SSRHTMLElement> = {
-    [K in keyof T]: Directive<void, U> | DirectiveAndParam<T[K], U>;
-};
-/**
- * A unique symbol representing an invalid value.
- * This can be used as a sentinel value to indicate that a variable or property
- * does not hold a valid value.
- */
-export declare const INVALID_VALUE: unique symbol;
-/**
- * A type alias for a function that normalizes a value of type `T`.
- * The function takes a value of type `T` and returns either a normalized value of type `T`
- * or a special constant `INVALID_VALUE` indicating that the value is invalid.
- *
- * @template T - The type of the value to be normalized.
- * @param value - The value to be normalized.
- * @returns The normalized value of type `T` or `INVALID_VALUE` if the value is invalid.
- */
-export type NormalizeValue<T> = (value: T) => T | typeof INVALID_VALUE;
-/**
- * Interface representing options for a writable store with default values.
- *
- * @template T - The type of the value stored.
- */
-export interface WritableWithDefaultOptions<T> {
-    /**
-     * the normalize value function. should return the {@link INVALID_VALUE} symbol when the provided value is invalid
-     */
-    normalizeValue?: NormalizeValue<T>;
-    /**
-     * the equal function, allowing to compare two values. used to check if a previous and current values are equals.
-     */
-    equal?: StoreOptions<T>['equal'];
-}
-/**
- * Represents a type that validates a configuration object.
- *
- * @template T - The type of the configuration object to be validated.
- *
- * This type maps each key of the configuration object `T` to an optional
- * `WritableWithDefaultOptions` type, allowing for partial validation.
- */
-export type ConfigValidator<T extends object> = {
-    [K in keyof T]: WritableWithDefaultOptions<T[K]> | undefined;
-};
-/**
- * Represents a value that can be assigned to an attribute.
- */
-export type AttributeValue = string | number | boolean | undefined;
-type CamelToKebab<S extends string> = S extends `${infer Head}${infer Tail}` ? `${Head extends Lowercase<Head> ? Head : `-${Lowercase<Head>}`}${CamelToKebab<Tail>}` : S;
-/**
- * Represents a key of the CSSStyleDeclaration interface (in camelCase), excluding certain properties and methods.
- *
- * This is useful for scenarios where you need to work with CSS properties directly without
- * dealing with the methods and other non-style properties of CSSStyleDeclaration.
- */
-export type StyleKeyCamelCase = Exclude<keyof CSSStyleDeclaration, 'length' | 'item' | 'parentRule' | 'getPropertyValue' | 'getPropertyPriority' | 'setProperty' | 'removeProperty' | typeof Symbol.iterator | number | 'cssText'>;
-/**
- * Represents a key of the CSSStyleDeclaration interface, converted to kebab-case, excluding certain properties and methods.
- *
- * This is useful for scenarios where you need to work with CSS properties directly without
- * dealing with the methods and other non-style properties of CSSStyleDeclaration.
- */
-export type StyleKeyKebabCase = CamelToKebab<StyleKeyCamelCase>;
-/**
- * Represents a CSS custom property key.
- * CSS custom properties are defined using the `--` prefix.
- */
-export type StyleKeyCustomProperty = `--${string}`;
-/**
- * Represents a key that can be used for styling purposes.
- * This includes camelCase style keys, kebab-case style keys, and CSS custom property keys.
- */
-export type StyleKey = StyleKeyCamelCase | StyleKeyKebabCase | StyleKeyCustomProperty;
-/**
- * Represents a value that can be used for styling purposes.
- * @remarks
- * This type can be a string representing a style value, or it can be undefined or null.
- * It is useful for scenarios where a style value might be optional or not set.
- */
-export type StyleValue = string | undefined | null;
-/**
- * A conditional type that checks if type `T` extends type `U`.
- * @template T - The type to check.
- * @template U - The type to check against.
- * @returns `1` if `T` extends `U`, otherwise `0`.
- */
-export type Extends<T, U> = T extends U ? 1 : 0;
-export {};

package/node_modules/@agnos-ui/core/types.js

@@ -1,6 +0,0 @@
-const FACTORY_WIDGET_NAME = /* @__PURE__ */ Symbol();
-const INVALID_VALUE = /* @__PURE__ */ Symbol();
-export {
-  FACTORY_WIDGET_NAME,
-  INVALID_VALUE
-};

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

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("@amadeus-it-group/tansu");
-require("esm-env");
-const utils_directive = require("../directive-DCaXmRe_.cjs");
-require("./func.cjs");
-exports.attributesData = utils_directive.attributesData;
-exports.bindDirective = utils_directive.bindDirective;
-exports.bindDirectiveNoArg = utils_directive.bindDirectiveNoArg;
-exports.browserDirective = utils_directive.browserDirective;
-exports.classDirective = utils_directive.classDirective;
-exports.conditionalDirective = utils_directive.conditionalDirective;
-exports.createAttributesDirective = utils_directive.createAttributesDirective;
-exports.createBrowserStoreArrayDirective = utils_directive.createBrowserStoreArrayDirective;
-exports.createBrowserStoreDirective = utils_directive.createBrowserStoreDirective;
-exports.createConditionalBrowserStoreArrayDirective = utils_directive.createConditionalBrowserStoreArrayDirective;
-exports.createConditionalStoreArrayDirective = utils_directive.createConditionalStoreArrayDirective;
-exports.createStoreArrayDirective = utils_directive.createStoreArrayDirective;
-exports.createStoreDirective = utils_directive.createStoreDirective;
-exports.directiveAttributes = utils_directive.directiveAttributes;
-exports.directiveSubscribe = utils_directive.directiveSubscribe;
-exports.directiveUpdate = utils_directive.directiveUpdate;
-exports.isBrowserHTMLElement = utils_directive.isBrowserHTMLElement;
-exports.mapDirectiveArg = utils_directive.mapDirectiveArg;
-exports.mergeDirectives = utils_directive.mergeDirectives;
-exports.multiDirective = utils_directive.multiDirective;
-exports.registrationArray = utils_directive.registrationArray;
-exports.ssrAttributes = utils_directive.ssrAttributes;