@design-factory/core 21.1.0-next.1

package/textDirection-cNgt24LJ.js

@@ -0,0 +1,4 @@
+const getTextDirection = (element) => getComputedStyle(element).direction;
+export {
+  getTextDirection as g
+};

package/textDirection-zqcZ5-eK.cjs

@@ -0,0 +1,3 @@
+"use strict";
+const getTextDirection = (element) => getComputedStyle(element).direction;
+exports.getTextDirection = getTextDirection;

package/toaster-BUBzFeJM.js

@@ -0,0 +1,162 @@
+import { computed, readable, writable } from "@amadeus-it-group/tansu";
+import { extendWidgetProps } from "./services/extendWidget.js";
+import { o as directiveSubscribe, g as createAttributesDirective } from "./directive-CNNSo5Yn.js";
+import { true$ } from "./utils/stores.js";
+import { h as typeNumberInRangeFactory, b as typeBoolean } from "./writables-DYGjj5T3.js";
+import { g as getCommonAlertDefaultConfig, c as createCommonAlert } from "./common-DFyZvkII.js";
+import { createWidgetFactory } from "./utils/widget.js";
+const toastDefaultConfig = {
+  autoHide: true,
+  delay: 5e3
+};
+const toastConfigValidator = {
+  autoHide: typeBoolean,
+  delay: typeNumberInRangeFactory(0, Infinity, { strict: true })
+};
+function getToastDefaultConfig() {
+  return { ...getCommonAlertDefaultConfig(), ...toastDefaultConfig };
+}
+const createToast = createWidgetFactory(
+  "toast",
+  (config) => {
+    let _timeout;
+    const extendedAlert = extendWidgetProps(
+      createCommonAlert,
+      toastDefaultConfig,
+      toastConfigValidator
+    )(config);
+    const time$ = computed(() => {
+      clearTimeout(_timeout);
+      if (extendedAlert.stores.autoHide$()) {
+        _timeout = setTimeout(() => void extendedAlert.api.close(), extendedAlert.stores.delay$());
+      }
+    });
+    const bodyDirective = createAttributesDirective(() => ({
+      attributes: {
+        role: readable("alert"),
+        "aria-atomic": readable("true"),
+        class: computed(() => extendedAlert.stores.className$())
+      },
+      classNames: {
+        "au-toast": true$,
+        toast: true$
+      }
+    }));
+    const closeButtonDirective = createAttributesDirective(() => ({
+      attributes: {
+        type: readable("button"),
+        "aria-label": computed(() => extendedAlert.stores.ariaCloseButtonLabel$())
+      },
+      events: {
+        click: () => void extendedAlert.api.close()
+      }
+    }));
+    return {
+      ...extendedAlert,
+      directives: {
+        ...extendedAlert.directives,
+        autoHideDirective: directiveSubscribe(time$),
+        bodyDirective,
+        closeButtonDirective
+      }
+    };
+  }
+);
+const defaultToasterProps = {
+  duration: 5e3,
+  position: "bottomRight",
+  dismissible: false
+};
+class Toaster {
+  constructor(props) {
+    this.#idCount = 0;
+    this.#toasts = writable([]);
+    this.toasts = computed(
+      () => this.#toasts().sort((a, b) => b.id - a.id).slice(0, this.options().limit)
+    );
+    this.options = writable(defaultToasterProps);
+    this.#timers = /* @__PURE__ */ new Map();
+    this.addTimer = (id, duration = this.options().duration) => {
+      if (duration > 0) {
+        this.#timers.set(id, {
+          timeout: setTimeout(() => this.removeToast(id), duration),
+          started: performance.now(),
+          duration
+        });
+      }
+    };
+    this.pauseTimer = (id) => {
+      if (this.#timers.has(id)) {
+        const timer = this.#timers.get(id);
+        if (timer && timer.timeout) {
+          clearTimeout(timer.timeout);
+          timer.timeout = null;
+          timer.paused = performance.now();
+        }
+      }
+    };
+    this.resumeTimer = (id) => {
+      if (this.#timers.has(id)) {
+        const timer = this.#timers.get(id);
+        if (timer) {
+          const paused = timer.paused ?? timer.started;
+          const elapsed = paused - timer.started;
+          const remaining = (timer.duration ?? 0) - elapsed;
+          this.addTimer(id, remaining);
+          timer.duration = remaining;
+          timer.paused = void 0;
+        }
+      }
+    };
+    this.eventsDirective = createAttributesDirective((id) => ({
+      events: {
+        pointerenter: () => this.options().pauseOnHover && this.pauseTimer(id()),
+        pointerleave: () => this.options().pauseOnHover && this.resumeTimer(id())
+      }
+    }));
+    this.addToast = (props2) => {
+      const autoHide = props2.autoHide ?? this.options().duration > 0;
+      this.#toasts.update((toasts) => [...toasts, { id: this.#idCount++, props: props2 }]);
+      if (autoHide) {
+        this.addTimer(this.#idCount - 1, props2.delay);
+      }
+      return this.#idCount - 1;
+    };
+    this.removeToast = (id) => {
+      this.#timers.delete(id);
+      this.#toasts.update((toasts) => toasts.filter((toast) => toast.id !== id));
+    };
+    this.updateToasts = () => {
+      if (this.options().duration === 0) {
+        this.options().dismissible = true;
+      }
+    };
+    this.closeAll = () => {
+      this.#toasts.set([]);
+      this.#timers.clear();
+    };
+    this.options.set({
+      ...defaultToasterProps,
+      ...props
+    });
+    this.options.subscribe(() => {
+      this.updateToasts();
+    });
+  }
+  #idCount;
+  #toasts;
+  #timers;
+  /**
+   * Get the timers value from the store
+   * @returns The map of timers.
+   */
+  get timers() {
+    return new Map(this.#timers);
+  }
+}
+export {
+  Toaster as T,
+  createToast as c,
+  defaultToasterProps as d,
+  getToastDefaultConfig as g
+};

package/toaster-Dlube4Ya.cjs

@@ -0,0 +1,161 @@
+"use strict";
+const tansu = require("@amadeus-it-group/tansu");
+const services_extendWidget = require("./services/extendWidget.cjs");
+const utils_directive = require("./directive-DyTodNPd.cjs");
+const utils_stores = require("./utils/stores.cjs");
+const utils_writables = require("./writables-Dt68gADJ.cjs");
+const common = require("./common-B5jS-Ih_.cjs");
+const utils_widget = require("./utils/widget.cjs");
+const toastDefaultConfig = {
+  autoHide: true,
+  delay: 5e3
+};
+const toastConfigValidator = {
+  autoHide: utils_writables.typeBoolean,
+  delay: utils_writables.typeNumberInRangeFactory(0, Infinity, { strict: true })
+};
+function getToastDefaultConfig() {
+  return { ...common.getCommonAlertDefaultConfig(), ...toastDefaultConfig };
+}
+const createToast = utils_widget.createWidgetFactory(
+  "toast",
+  (config) => {
+    let _timeout;
+    const extendedAlert = services_extendWidget.extendWidgetProps(
+      common.createCommonAlert,
+      toastDefaultConfig,
+      toastConfigValidator
+    )(config);
+    const time$ = tansu.computed(() => {
+      clearTimeout(_timeout);
+      if (extendedAlert.stores.autoHide$()) {
+        _timeout = setTimeout(() => void extendedAlert.api.close(), extendedAlert.stores.delay$());
+      }
+    });
+    const bodyDirective = utils_directive.createAttributesDirective(() => ({
+      attributes: {
+        role: tansu.readable("alert"),
+        "aria-atomic": tansu.readable("true"),
+        class: tansu.computed(() => extendedAlert.stores.className$())
+      },
+      classNames: {
+        "au-toast": utils_stores.true$,
+        toast: utils_stores.true$
+      }
+    }));
+    const closeButtonDirective = utils_directive.createAttributesDirective(() => ({
+      attributes: {
+        type: tansu.readable("button"),
+        "aria-label": tansu.computed(() => extendedAlert.stores.ariaCloseButtonLabel$())
+      },
+      events: {
+        click: () => void extendedAlert.api.close()
+      }
+    }));
+    return {
+      ...extendedAlert,
+      directives: {
+        ...extendedAlert.directives,
+        autoHideDirective: utils_directive.directiveSubscribe(time$),
+        bodyDirective,
+        closeButtonDirective
+      }
+    };
+  }
+);
+const defaultToasterProps = {
+  duration: 5e3,
+  position: "bottomRight",
+  dismissible: false
+};
+class Toaster {
+  constructor(props) {
+    this.#idCount = 0;
+    this.#toasts = tansu.writable([]);
+    this.toasts = tansu.computed(
+      () => this.#toasts().sort((a, b) => b.id - a.id).slice(0, this.options().limit)
+    );
+    this.options = tansu.writable(defaultToasterProps);
+    this.#timers = /* @__PURE__ */ new Map();
+    this.addTimer = (id, duration = this.options().duration) => {
+      if (duration > 0) {
+        this.#timers.set(id, {
+          timeout: setTimeout(() => this.removeToast(id), duration),
+          started: performance.now(),
+          duration
+        });
+      }
+    };
+    this.pauseTimer = (id) => {
+      if (this.#timers.has(id)) {
+        const timer = this.#timers.get(id);
+        if (timer && timer.timeout) {
+          clearTimeout(timer.timeout);
+          timer.timeout = null;
+          timer.paused = performance.now();
+        }
+      }
+    };
+    this.resumeTimer = (id) => {
+      if (this.#timers.has(id)) {
+        const timer = this.#timers.get(id);
+        if (timer) {
+          const paused = timer.paused ?? timer.started;
+          const elapsed = paused - timer.started;
+          const remaining = (timer.duration ?? 0) - elapsed;
+          this.addTimer(id, remaining);
+          timer.duration = remaining;
+          timer.paused = void 0;
+        }
+      }
+    };
+    this.eventsDirective = utils_directive.createAttributesDirective((id) => ({
+      events: {
+        pointerenter: () => this.options().pauseOnHover && this.pauseTimer(id()),
+        pointerleave: () => this.options().pauseOnHover && this.resumeTimer(id())
+      }
+    }));
+    this.addToast = (props2) => {
+      const autoHide = props2.autoHide ?? this.options().duration > 0;
+      this.#toasts.update((toasts) => [...toasts, { id: this.#idCount++, props: props2 }]);
+      if (autoHide) {
+        this.addTimer(this.#idCount - 1, props2.delay);
+      }
+      return this.#idCount - 1;
+    };
+    this.removeToast = (id) => {
+      this.#timers.delete(id);
+      this.#toasts.update((toasts) => toasts.filter((toast) => toast.id !== id));
+    };
+    this.updateToasts = () => {
+      if (this.options().duration === 0) {
+        this.options().dismissible = true;
+      }
+    };
+    this.closeAll = () => {
+      this.#toasts.set([]);
+      this.#timers.clear();
+    };
+    this.options.set({
+      ...defaultToasterProps,
+      ...props
+    });
+    this.options.subscribe(() => {
+      this.updateToasts();
+    });
+  }
+  #idCount;
+  #toasts;
+  #timers;
+  /**
+   * Get the timers value from the store
+   * @returns The map of timers.
+   */
+  get timers() {
+    return new Map(this.#timers);
+  }
+}
+exports.Toaster = Toaster;
+exports.createToast = createToast;
+exports.defaultToasterProps = defaultToasterProps;
+exports.getToastDefaultConfig = getToastDefaultConfig;

package/tree-Chcy4ulJ.cjs

@@ -0,0 +1,228 @@
+"use strict";
+const tansu = require("@amadeus-it-group/tansu");
+const services_navManager = require("./services/navManager.cjs");
+const utils_directive = require("./directive-DyTodNPd.cjs");
+const utils_func = require("./utils/func.cjs");
+const utils_stores = require("./utils/stores.cjs");
+const utils_writables = require("./writables-Dt68gADJ.cjs");
+const utils_widget = require("./utils/widget.cjs");
+function getTreeDefaultConfig() {
+  return {
+    ...defaultTreeConfig
+  };
+}
+const defaultTreeConfig = {
+  className: "",
+  nodes: [],
+  onExpandToggle: utils_func.noop,
+  navSelector: (node) => node.querySelectorAll("button"),
+  ariaLabelToggleFn: (label) => `Toggle ${label}`
+};
+const configValidator = {
+  className: utils_writables.typeString,
+  nodes: utils_writables.typeArray,
+  onExpandToggle: utils_writables.typeFunction,
+  navSelector: utils_writables.typeFunction,
+  ariaLabelToggleFn: utils_writables.typeFunction
+};
+const createTree = utils_widget.createWidgetFactory("tree", (config) => {
+  const [{ nodes$, onExpandToggle$, navSelector$, ariaLabelToggleFn$, ...stateProps }, patch] = utils_stores.writablesForProps(
+    defaultTreeConfig,
+    config,
+    configValidator
+  );
+  const treeMap = /* @__PURE__ */ new Map();
+  const _expandedMap = {
+    get(item) {
+      return item.isExpanded;
+    }
+  };
+  const _toggleChange$ = tansu.writable({});
+  const expandedMap$ = tansu.computed(() => {
+    normalizedNodes$();
+    _toggleChange$();
+    return _expandedMap;
+  });
+  const {
+    elementsInDomOrder$,
+    directive: navDirective,
+    refreshElements,
+    focusIndex,
+    focusPrevious,
+    focusNext,
+    focusFirst,
+    focusLast
+  } = services_navManager.createNavManager();
+  const navManagerConfig$ = tansu.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$ = tansu.computed(() => {
+    treeMap.clear();
+    return nodes$().map((node) => traverseTree(node, 0, void 0));
+  });
+  const _lastFocusedTreeItem$ = tansu.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 = utils_directive.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 = utils_directive.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": tansu.computed(() => {
+          const { item } = treeItemContext$();
+          return ariaLabelToggleFn$()(item.ariaLabel);
+        }),
+        tabindex: tansu.computed(() => {
+          const { item } = treeItemContext$();
+          return item === _lastFocusedTreeItem$() ? "0" : "-1";
+        }),
+        type: tansu.readable("button")
+      },
+      classNames: {
+        "au-tree-expand-icon": utils_stores.true$,
+        "au-tree-expand-icon-expanded": tansu.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 = {
+    ...utils_stores.stateStores({ normalizedNodes$, expandedMap$, ...stateProps }),
+    patch,
+    api: {},
+    directives: {
+      navigationDirective: utils_directive.bindDirective(navDirective, navManagerConfig$),
+      itemToggleDirective: utils_directive.mergeDirectives(treeItemElementDirective, itemToggleAttributesDirective),
+      itemAttributesDirective: utils_directive.createAttributesDirective(
+        (treeItemContext$) => ({
+          attributes: {
+            role: tansu.readable("treeitem"),
+            "aria-selected": tansu.readable("false"),
+            // TODO: adapt aria-selected to the actual selected state
+            "aria-expanded": tansu.computed(() => {
+              const { item } = treeItemContext$();
+              _toggleChange$();
+              return item.isExpanded?.toString();
+            })
+          }
+        })
+      )
+    }
+  };
+  return widget;
+});
+exports.createTree = createTree;
+exports.getTreeDefaultConfig = getTreeDefaultConfig;