@design-factory/core 21.1.0 → 22.0.0-next.1

package/{slider-Br_Qiopx.js → slider-tH5g55yQ.js}

@@ -1,11 +1,12 @@
-import { computed, writable, readable } from "@amadeus-it-group/tansu";
-import { i as createBrowserStoreDirective, h as createBrowserStoreArrayDirective, s as mergeDirectives, g as createAttributesDirective, d as browserDirective } from "./directive-CNNSo5Yn.js";
+import { computed, derived, writable, readable } from "@amadeus-it-group/tansu";
+import { i as createBrowserStoreDirective, h as createBrowserStoreArrayDirective, s as mergeDirectives, g as createAttributesDirective, o as directiveSubscribe, d as browserDirective } from "./directive-CMT2vEDg.js";
 import { noop } from "./utils/func.js";
 import { writablesForProps, bindableProp, true$, stateStores } from "./utils/stores.js";
-import { h as typeNumberInRangeFactory, b as typeBoolean, j as typeString, a as typeArray, e as typeFunction, g as typeNumber, l as clamp } from "./writables-DYGjj5T3.js";
+import { i as typeNumberInRangeFactory, d as typeBoolean, k as typeString, b as typeArray, f as typeFunction, h as typeNumber, m as clamp } from "./writables-_7BriMb2.js";
 import { createResizeObserver, createResizeObserverMap } from "./services/resizeObserver.js";
 import { createPointerdownPositionDirective } from "./services/pointerdownPosition.js";
 import { createWidgetFactory } from "./utils/widget.js";
+import { g as getTextDirection } from "./textDirection-cNgt24LJ.js";
 const decimalRegExp = /(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
 function getDecimalPrecision(number) {
   const matches = ("" + number).match(decimalRegExp);
@@ -90,7 +91,8 @@ const defaultSliderConfig = {
   minRange: 0,
   maxRange: 0,
   pushRange: false,
-  rtl: false
+  flip: false,
+  rtl: void 0
 };
 function getSliderDefaultConfig() {
   return { ...defaultSliderConfig };
@@ -112,6 +114,7 @@ const configValidator = {
   showTicks: typeBoolean,
   showTickValues: typeBoolean,
   tickInterval: typeNumberInRangeFactory(0, Infinity, { strict: true }),
+  flip: typeBoolean,
   rtl: typeBoolean,
   className: typeString,
   minRange: typeNumberInRangeFactory(0, Infinity),
@@ -128,13 +131,6 @@ const computeCleanValue = (value, min, max, intStepSize, decimalPrecision) => {
   const indexMin = Math.floor((value - min) * magnitude / intStepSize);
   return +(((value - min) * magnitude % intStepSize < intStepSize / 2 ? indexMin : indexMin + 1) * intStepSize / magnitude + min).toFixed(decimalPrecision);
 };
-const updateValue = (handleIndex, values$, stepSize, updateDirection) => {
-  values$.update((value) => {
-    value = [...value];
-    value[handleIndex] = value[handleIndex] + stepSize * updateDirection;
-    return value;
-  });
-};
 const getUpdateDirection = (vertical, rtl, keysVertical) => {
   if (vertical && rtl) {
     return keysVertical ? 1 : -1;
@@ -160,6 +156,7 @@ const createSlider = createWidgetFactory(
         maxRange$: _dirtyMaximumRange$,
         pushRange$,
         stepSize$,
+        flip$,
         rtl$,
         values$: _dirtyValues$,
         ariaLabel$,
@@ -211,7 +208,6 @@ const createSlider = createWidgetFactory(
       () => Math.max(getDecimalPrecision(stepSize$()), getDecimalPrecision(min$()), getDecimalPrecision(max$()))
     );
     const _intStepSize$ = computed(() => stepSize$() * Math.pow(10, _decimalPrecision$()));
-    let previousValues = _dirtyValues$();
     const values$ = bindableProp(
       _dirtyValues$,
       onValuesChange$,
@@ -220,23 +216,28 @@ const createSlider = createWidgetFactory(
         const max = max$();
         const intStepSize = _intStepSize$();
         const decimalPrecision = _decimalPrecision$();
-        const newValues = dirtyValues.map((dv) => computeCleanValue(dv, min, max, intStepSize, decimalPrecision));
-        if (dirtyValues.length > 1) {
+        return dirtyValues.map((dv) => computeCleanValue(dv, min, max, intStepSize, decimalPrecision));
+      },
+      typeArray.equal
+    );
+    const updateValueAtIndex = (index, newValue) => {
+      values$.update((vals) => {
+        const min = min$();
+        const max = max$();
+        const intStepSize = _intStepSize$();
+        const decimalPrecision = _decimalPrecision$();
+        const newVals = [...vals];
+        newVals[index] = computeCleanValue(newValue, min, max, intStepSize, decimalPrecision);
+        if (newVals.length > 1) {
           const minRange = minRange$();
           const maxRange = maxRange$();
           if (minRange || maxRange) {
-            const pushRange = pushRange$();
-            const changedIndex = newValues.findIndex((dv, index) => dv !== previousValues[index]);
-            if (changedIndex !== -1) {
-              manageMinMaxRange(newValues, changedIndex, minRange, maxRange, min, max, pushRange);
-            }
+            manageMinMaxRange(newVals, index, minRange, maxRange, min, max, pushRange$());
           }
         }
-        previousValues = newValues;
-        return newValues;
-      },
-      typeArray.equal
-    );
+        return newVals;
+      });
+    };
     const { directive: sliderDirective, element$: sliderDom$ } = createBrowserStoreDirective();
     const { directive: minLabelDomDirective, element$: minLabelDom$ } = createBrowserStoreDirective();
     const { directive: maxLabelDomDirective, element$: maxLabelDom$ } = createBrowserStoreDirective();
@@ -244,6 +245,31 @@ const createSlider = createWidgetFactory(
     const { directive: resizeDirective, dimensions$ } = createResizeObserver();
     const { directive: resizeLabelsDirective, dimensionsMap$: handleDimensions$ } = createResizeObserverMap();
     const { directive: resizeCombineLabelDirective, dimensions$: combinedDimensions$ } = createResizeObserver();
+    const autoDetectedRtl$ = derived(
+      sliderDom$,
+      (el, set) => {
+        if (!el) {
+          set(false);
+          return noop;
+        }
+        set(getTextDirection(el) === "rtl");
+        const observer = new MutationObserver(() => {
+          set(getTextDirection(el) === "rtl");
+        });
+        let current = el;
+        while (current) {
+          observer.observe(current, { attributes: true, attributeFilter: ["dir"] });
+          current = current.parentElement;
+        }
+        return () => observer.disconnect();
+      },
+      false
+    );
+    const resolvedRtl$ = computed(() => {
+      const explicit = rtl$();
+      return explicit !== void 0 ? explicit : autoDetectedRtl$();
+    });
+    const effectiveRtl$ = computed(() => resolvedRtl$() !== flip$());
     const updateSliderSize$ = writable({});
     const sliderDomRect$ = computed(
       () => {
@@ -315,7 +341,7 @@ const createSlider = createWidgetFactory(
       }
       const minLabelSize = minLabelSize$();
       const vertical = vertical$();
-      const rtl = rtl$();
+      const rtl = effectiveRtl$();
       if (combinedLabelDisplay$()) {
         const combinedLabelSize = combinedLabelSize$();
         const combinedLabelPosition = combinedLabelPosition$();
@@ -332,7 +358,7 @@ const createSlider = createWidgetFactory(
       }
       const maxLabelSize = maxLabelSize$();
       const vertical = vertical$();
-      const rtl = rtl$();
+      const rtl = effectiveRtl$();
       if (combinedLabelDisplay$()) {
         const combinedLabelSize = combinedLabelSize$();
         const combinedLabelPosition = combinedLabelPosition$();
@@ -369,15 +395,15 @@ const createSlider = createWidgetFactory(
       const combinedLabelSize = combinedLabelSize$();
       let combinedPosition = (sortedValuesPercent[0] + sortedValuesPercent[1]) / 2;
       combinedPosition = labelPosition(combinedPosition, combinedLabelSize);
-      return vertical$() || sortedValuesPercent.length != 2 ? 0 : rtl$() ? 100 - combinedPosition : combinedPosition;
+      return vertical$() || sortedValuesPercent.length != 2 ? 0 : effectiveRtl$() ? 100 - combinedPosition : combinedPosition;
     });
     const combinedLabelPositionTop$ = computed(() => {
       const sortedValuesPercent = sortedValuesPercent$();
       const combinedPosition = 100 - (sortedValuesPercent[0] + sortedValuesPercent[1]) / 2;
-      return vertical$() && sortedValuesPercent.length == 2 ? rtl$() ? 100 - combinedPosition : combinedPosition : 0;
+      return vertical$() && sortedValuesPercent.length == 2 ? effectiveRtl$() ? 100 - combinedPosition : combinedPosition : 0;
     });
     const handleDisplayOptions$ = computed(() => {
-      const vertical = vertical$(), rtl = rtl$();
+      const vertical = vertical$(), rtl = effectiveRtl$();
       return valuesPercent$().map((vp) => {
         return {
           left: rtl ? vertical ? null : 100 - vp : vertical ? null : vp,
@@ -387,7 +413,7 @@ const createSlider = createWidgetFactory(
     });
     const labelPosition = (initialPosition, labelSize) => clamp(initialPosition, 100 - labelSize / 2, labelSize / 2);
     const progressDisplayOptions$ = computed(() => {
-      const vertical = vertical$(), sortedValuesPercent = sortedValuesPercent$(), rtl = rtl$();
+      const vertical = vertical$(), sortedValuesPercent = sortedValuesPercent$(), rtl = effectiveRtl$();
       if (sortedValuesPercent.length === 1) {
         return [
           {
@@ -421,7 +447,7 @@ const createSlider = createWidgetFactory(
       const vertical = vertical$();
       const min = min$();
       const max = max$();
-      const rtl = rtl$();
+      const rtl = effectiveRtl$();
       const showTickValues = showTickValues$();
       const tickInterval = tickInterval$() || stepSize$();
       const tickArray = [];
@@ -479,7 +505,7 @@ const createSlider = createWidgetFactory(
     const getClickedPercent = (clickedCoordinate) => {
       const sliderDomRectSize = sliderDomRectSize$(), sliderDomRectOffset = sliderDomRectOffset$();
       let clickedPercent = vertical$() ? (sliderDomRectSize - clickedCoordinate + sliderDomRectOffset) / sliderDomRectSize : (clickedCoordinate - sliderDomRectOffset) / sliderDomRectSize;
-      clickedPercent = rtl$() ? 1 - clickedPercent : clickedPercent;
+      clickedPercent = effectiveRtl$() ? 1 - clickedPercent : clickedPercent;
       return clickedPercent;
     };
     const adjustCoordinate = (clickedCoordinate, handleNumber) => {
@@ -487,19 +513,15 @@ const createSlider = createWidgetFactory(
         const clickedPercent = getClickedPercent(clickedCoordinate);
         const derivedHandleIndex = handleNumber ?? getClosestSliderHandle(clickedPercent);
         const newValue = clickedPercent * (max$() - min$()) + min$();
-        values$.update((dh) => {
-          dh = [...dh];
-          dh[derivedHandleIndex] = newValue;
-          return dh;
-        });
+        updateValueAtIndex(derivedHandleIndex, newValue);
       }
     };
     const horizontal$ = computed(() => !vertical$());
     const containerDirective = createAttributesDirective(() => ({
       classNames: {
-        "au-slider": true$,
-        "au-slider-vertical": vertical$,
-        "au-slider-horizontal": horizontal$
+        "df-slider": true$,
+        "df-slider-vertical": vertical$,
+        "df-slider-horizontal": horizontal$
       },
       attributes: {
         class: stateProps.className$
@@ -511,23 +533,23 @@ const createSlider = createWidgetFactory(
         class: stateProps.className$
       },
       classNames: {
-        "au-slider-content": true$,
-        "au-slider-vertical": vertical$,
-        "au-slider-horizontal": horizontal$,
-        "au-slider-with-labels": computed(
+        "df-slider-content": true$,
+        "df-slider-vertical": vertical$,
+        "df-slider-horizontal": horizontal$,
+        "df-slider-with-labels": computed(
           () => showValueLabels$() || showMinMaxLabels$() || showTickValues$() && showTicks$()
         ),
-        disabled: disabled$
+        "df-slider-disabled": disabled$
       }
     }));
     const minLabelDirective = createAttributesDirective(() => ({
       classNames: {
-        "au-slider-label-vertical": vertical$,
-        "au-slider-label-vertical-min": vertical$,
-        "au-slider-label": horizontal$,
-        "au-slider-label-min": horizontal$,
-        "au-slider-rtl": rtl$,
-        invisible: computed(() => !minValueLabelDisplay$())
+        "df-slider-label-vertical": vertical$,
+        "df-slider-label-vertical-min": vertical$,
+        "df-slider-label": horizontal$,
+        "df-slider-label-min": horizontal$,
+        "df-slider-rtl": effectiveRtl$,
+        "df-slider-invisible": computed(() => !minValueLabelDisplay$())
       },
       attributes: {
         "aria-hidden": readable("true")
@@ -535,12 +557,12 @@ const createSlider = createWidgetFactory(
     }));
     const maxLabelDirective = createAttributesDirective(() => ({
       classNames: {
-        "au-slider-label-vertical": vertical$,
-        "au-slider-label-vertical-max": vertical$,
-        "au-slider-label": horizontal$,
-        "au-slider-label-max": horizontal$,
-        "au-slider-rtl": rtl$,
-        invisible: computed(() => !maxValueLabelDisplay$())
+        "df-slider-label-vertical": vertical$,
+        "df-slider-label-vertical-max": vertical$,
+        "df-slider-label": horizontal$,
+        "df-slider-label-max": horizontal$,
+        "df-slider-rtl": effectiveRtl$,
+        "df-slider-invisible": computed(() => !maxValueLabelDisplay$())
       },
       attributes: {
         "aria-hidden": readable("true")
@@ -588,34 +610,38 @@ const createSlider = createWidgetFactory(
           keydown: (event) => {
             const handleIndex = handleContext$().item.id;
             const { key } = event;
-            const rtl = rtl$(), stepSize = stepSize$(), min = min$(), max = max$(), vertical = vertical$();
+            const rtl = effectiveRtl$(), stepSize = stepSize$(), min = min$(), max = max$(), vertical = vertical$();
             if (interactive$()) {
               switch (key) {
                 case "ArrowDown":
-                  updateValue(handleIndex, values$, stepSize, getUpdateDirection(vertical, rtl, true));
+                  updateValueAtIndex(
+                    handleIndex,
+                    values$()[handleIndex] + stepSize * getUpdateDirection(vertical, rtl, true)
+                  );
                   break;
                 case "ArrowLeft":
-                  updateValue(handleIndex, values$, stepSize, getUpdateDirection(vertical, rtl, false));
+                  updateValueAtIndex(
+                    handleIndex,
+                    values$()[handleIndex] + stepSize * getUpdateDirection(vertical, rtl, false)
+                  );
                   break;
                 case "ArrowUp":
-                  updateValue(handleIndex, values$, stepSize, -1 * getUpdateDirection(vertical, rtl, true));
+                  updateValueAtIndex(
+                    handleIndex,
+                    values$()[handleIndex] + stepSize * -1 * getUpdateDirection(vertical, rtl, true)
+                  );
                   break;
                 case "ArrowRight":
-                  updateValue(handleIndex, values$, stepSize, -1 * getUpdateDirection(vertical, rtl, false));
+                  updateValueAtIndex(
+                    handleIndex,
+                    values$()[handleIndex] + stepSize * -1 * getUpdateDirection(vertical, rtl, false)
+                  );
                   break;
                 case "Home":
-                  values$.update((value) => {
-                    value = [...value];
-                    value[handleIndex] = min;
-                    return value;
-                  });
+                  updateValueAtIndex(handleIndex, min);
                   break;
                 case "End":
-                  values$.update((value) => {
-                    value = [...value];
-                    value[handleIndex] = max;
-                    return value;
-                  });
+                  updateValueAtIndex(handleIndex, max);
                   break;
                 case "PageUp":
                   break;
@@ -652,14 +678,23 @@ const createSlider = createWidgetFactory(
         showValueLabels$: adjustedShowValueLabels$,
         showMinMaxLabels$,
         showTicks$,
-        rtl$,
+        flip$,
+        rtl$: resolvedRtl$,
         ticks$,
         ...stateProps
       }),
       patch,
       api: {},
       directives: {
-        sliderDirective: mergeDirectives(sliderDirective, resizeDirective, contentDirective),
+        // Eagerly subscribe to dimensions$ so the slider-content ResizeObserver is active before the
+        // value-label ResizeObserver callback runs. This prevents the "ResizeObserver loop completed
+        // with undelivered notifications" error caused by label layout changes triggered mid-callback.
+        sliderDirective: mergeDirectives(
+          sliderDirective,
+          resizeDirective,
+          directiveSubscribe(dimensions$),
+          contentDirective
+        ),
         containerDirective,
         progressDisplayDirective: createAttributesDirective(
           (progressContext$) => ({
@@ -672,16 +707,16 @@ const createSlider = createWidgetFactory(
               height: computed(() => percent(progressContext$().option.height))
             },
             classNames: {
-              "au-slider-progress": true$
+              "df-slider-progress": true$
             }
           })
         ),
         clickableAreaDirective: mergeDirectives(
           createAttributesDirective(() => ({
             classNames: {
-              "au-slider-clickable-area": horizontal$,
-              "au-slider-clickable-area-vertical": vertical$,
-              "au-slider-clickable-area-with-ticks": computed(() => showTicks$() && tickInterval$() === 0)
+              "df-slider-clickable-area": horizontal$,
+              "df-slider-clickable-area-vertical": vertical$,
+              "df-slider-clickable-area-with-ticks": computed(() => showTicks$() && tickInterval$() === 0)
             }
           })),
           createPointerdownPositionDirective((position) => {
@@ -714,9 +749,9 @@ const createSlider = createWidgetFactory(
               top: computed(() => percent(handleDisplayOptions$()[handleContext$().item.id].top))
             },
             classNames: {
-              "au-slider-handle": true$,
-              "au-slider-handle-vertical": vertical$,
-              "au-slider-handle-horizontal": horizontal$
+              "df-slider-handle": true$,
+              "df-slider-handle-vertical": vertical$,
+              "df-slider-handle-horizontal": horizontal$
             }
           }))
         ),
@@ -726,14 +761,14 @@ const createSlider = createWidgetFactory(
           resizeCombineLabelDirective,
           createAttributesDirective(() => ({
             classNames: {
-              "au-slider-label-vertical": vertical$,
-              "au-slider-label-vertical-now": vertical$,
-              "au-slider-label": horizontal$,
-              "au-slider-label-now": horizontal$
+              "df-slider-label-vertical": vertical$,
+              "df-slider-label-vertical-now": vertical$,
+              "df-slider-label": horizontal$,
+              "df-slider-label-now": horizontal$
             },
             styles: {
-              left: computed(() => percent(combinedLabelPositionLeft$())),
-              top: computed(() => percent(combinedLabelPositionTop$()))
+              left: computed(() => vertical$() ? "" : percent(combinedLabelPositionLeft$())),
+              top: computed(() => vertical$() ? percent(combinedLabelPositionTop$()) : "")
             },
             attributes: {
               "aria-hidden": readable("true")
@@ -745,10 +780,10 @@ const createSlider = createWidgetFactory(
           resizeLabelsDirective,
           createAttributesDirective((labelDisplayContext$) => ({
             classNames: {
-              "au-slider-label-vertical": vertical$,
-              "au-slider-label-vertical-now": vertical$,
-              "au-slider-label": horizontal$,
-              "au-slider-label-now": horizontal$
+              "df-slider-label-vertical": vertical$,
+              "df-slider-label-vertical-now": vertical$,
+              "df-slider-label": horizontal$,
+              "df-slider-label-now": horizontal$
             },
             styles: {
               left: computed(() => {
@@ -766,9 +801,9 @@ const createSlider = createWidgetFactory(
         ),
         tickDirective: createAttributesDirective((tickContext$) => ({
           classNames: {
-            "au-slider-tick": true$,
-            "au-slider-tick-horizontal": horizontal$,
-            "au-slider-tick-vertical": vertical$
+            "df-slider-tick": true$,
+            "df-slider-tick-horizontal": horizontal$,
+            "df-slider-tick-vertical": vertical$
           },
           styles: {
             left: computed(() => vertical$() ? null : percent(tickContext$().tick.position)),
@@ -785,9 +820,9 @@ const createSlider = createWidgetFactory(
         })),
         tickLabelDirective: createAttributesDirective((tickContext$) => ({
           classNames: {
-            "au-slider-tick-label": true$,
-            "au-slider-tick-label-vertical": vertical$,
-            "au-slider-tick-label-now": computed(() => sortedValues$().some((sv) => sv === tickContext$().tick.value))
+            "df-slider-tick-label": true$,
+            "df-slider-tick-label-vertical": vertical$,
+            "df-slider-tick-label-now": computed(() => sortedValues$().some((sv) => sv === tickContext$().tick.value))
           },
           styles: {
             left: computed(() => vertical$() ? null : percent(tickContext$().tick.position)),

package/{toaster-BUBzFeJM.js → toaster-BS9qeRLF.js}

@@ -1,9 +1,9 @@
 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 { o as directiveSubscribe, g as createAttributesDirective } from "./directive-CMT2vEDg.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 { i as typeNumberInRangeFactory, d as typeBoolean } from "./writables-_7BriMb2.js";
+import { g as getCommonAlertDefaultConfig, c as createCommonAlert } from "./common-CP4amR0Z.js";
 import { createWidgetFactory } from "./utils/widget.js";
 const toastDefaultConfig = {
   autoHide: true,

package/{tree-vD7ZkV8Z.js → tree-DW6iLxdw.js}

@@ -1,9 +1,9 @@
 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-CNNSo5Yn.js";
+import { s as mergeDirectives, d as browserDirective, g as createAttributesDirective, b as bindDirective } from "./directive-CMT2vEDg.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 { f as typeFunction, b as typeArray, k as typeString } from "./writables-_7BriMb2.js";
 import { createWidgetFactory } from "./utils/widget.js";
 function getTreeDefaultConfig() {
   return {

package/types.d.ts

@@ -173,7 +173,14 @@ export declare const INVALID_VALUE: unique symbol;
  * @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;
+export type NormalizeValue<T> = (value: unknown) => T | typeof INVALID_VALUE;
+/**
+ * Makes the specified keys of a type required while keeping the rest unchanged.
+ *
+ * @template T - The original type.
+ * @template K - The keys to make required.
+ */
+export type PickRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
 /**
  * Interface representing options for a writable store with default values.
  *

package/utils/debounceSignal.d.ts

@@ -0,0 +1,11 @@
+import { ReadableSignal } from '@amadeus-it-group/tansu';
+/**
+ * Creates a debounced readable signal from a source signal.
+ *
+ * @template T - The type of the signal value
+ * @param source$ - The source readable signal to debounce
+ * @param delay - The debounce delay in milliseconds, or a function that returns the delay based on the value. If the delay is negative, the value is emitted immediately without debouncing.
+ * @param initialValue - The initial value of the debounced signal (defaults to the source signal's current value)
+ * @returns A readable signal that emits values from the source signal after the specified delay
+ */
+export declare const debounceSignal: <T>(source$: ReadableSignal<T>, delay: number | ((value: T) => number), initialValue?: T) => ReadableSignal<T>;

package/utils/debounceSignal.js

@@ -0,0 +1,18 @@
+import { derived } from "@amadeus-it-group/tansu";
+const debounceSignal = (source$, delay, initialValue = source$()) => derived(
+  source$,
+  (value, set) => {
+    const delayValue = typeof delay === "function" ? delay(value) : delay;
+    if (delayValue >= 0) {
+      const timeout = setTimeout(() => set(value), delayValue);
+      return () => clearTimeout(timeout);
+    } else {
+      set(value);
+      return void 0;
+    }
+  },
+  initialValue
+);
+export {
+  debounceSignal
+};

package/utils/directive.js

@@ -1,6 +1,6 @@
 import "@amadeus-it-group/tansu";
 import "esm-env";
-import { a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v } from "../directive-CNNSo5Yn.js";
+import { a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v } from "../directive-CMT2vEDg.js";
 import "./func.js";
 export {
   a as attributesData,

package/utils/edgeState.d.ts

@@ -0,0 +1,23 @@
+import type { ReadableSignal, WritableSignal } from '@amadeus-it-group/tansu';
+export interface EdgeState<Source extends string = string> extends WritableSignal<boolean> {
+    /**
+     * Skips the next update from a source when it matches the provided value.
+     *
+     * @param source - The source signal to skip the next matching update from.
+     * @param value - The value to skip.
+     */
+    skipNextSourceValue: (source: Source, value: boolean) => void;
+}
+/**
+ * Creates an edge-triggered boolean state from multiple input signals.
+ *
+ * Unlike a simple `computed(() => a() || b())`, this tracks which input signal
+ * last changed and adopts its value. This enables a "dismissed" state: an imperative
+ * `set(false)` hides the output even while some inputs remain `true`, and the next
+ * edge (any input changing) overrides the imperative value.
+ *
+ * @param sources - Boolean signals to track. The output follows whichever one last changed.
+ * @param guard - Optional signal that forces the output to `false` while truthy (e.g. `disabled$`).
+ * @return A writable signal that can be set imperatively, but also updates on edges of the input signals.
+ */
+export declare const createEdgeState: <const Sources extends Record<string, ReadableSignal<boolean>>>(sources: Sources, guard?: ReadableSignal<boolean>) => EdgeState<keyof Sources & string>;

package/utils/edgeState.js

@@ -0,0 +1,43 @@
+import { writable, computed, asWritable } from "@amadeus-it-group/tansu";
+const createEdgeState = (sources, guard) => {
+  const sourceList = Object.entries(sources).map(([name, signal]) => ({
+    name,
+    signal,
+    current: false,
+    previous: false
+  }));
+  const sourceByName = new Map(sourceList.map((source) => [source.name, source]));
+  let prevTrigger = { value: false };
+  const trigger$ = writable(prevTrigger);
+  let state = false;
+  const state$ = computed(() => {
+    for (const source of sourceList) {
+      source.current = source.signal();
+    }
+    const t = trigger$();
+    if (guard?.()) {
+      state = false;
+    } else {
+      const changed = sourceList.find((source) => source.current !== source.previous);
+      if (changed !== void 0) {
+        state = changed.current;
+      } else if (t !== prevTrigger) {
+        state = t.value;
+      }
+    }
+    for (const source of sourceList) {
+      source.previous = source.current;
+    }
+    prevTrigger = t;
+    return state;
+  });
+  return asWritable(state$, {
+    set: (v) => trigger$.set({ value: v }),
+    skipNextSourceValue: (source, value) => {
+      sourceByName.get(source).previous = value;
+    }
+  });
+};
+export {
+  createEdgeState
+};

package/utils/internal/isFocusable.d.ts

@@ -7,3 +7,43 @@
  * @returns true if the element is programmatically focusable.
  */
 export declare const isFocusable: (element: HTMLElement) => boolean;
+/**
+ * Returns the next element in depth-first order after the given element's subtree
+ * (i.e. without descending into its descendants), or null if there is none.
+ *
+ * @param element - element whose subtree should be skipped
+ * @returns the next element after the subtree, or null.
+ */
+export declare const findNextElementSkippingSubtree: (element: HTMLElement) => HTMLElement | null;
+/**
+ * Returns the next element after the given one in depth-first (pre-order) document order,
+ * or null if the given element is the last one in the document.
+ *
+ * @param element - element to start from
+ * @returns the next element in depth-first order, or null.
+ */
+export declare const findNextElement: (element: HTMLElement) => HTMLElement | null;
+/**
+ * Returns the previous element before the given one in depth-first (pre-order) document order,
+ * or null if the given element is the first one in the document.
+ *
+ * @param element - element to start from
+ * @returns the previous element in depth-first order, or null.
+ */
+export declare const findPreviousElement: (element: HTMLElement) => HTMLElement | null;
+/**
+ * Finds the next focusable element after the given one in document order.
+ *
+ * @param element - element to start from
+ * @param findNextElementFn - optional function to customize element traversal order (defaults to depth-first pre-order)
+ * @returns the next focusable element, or null if none found.
+ */
+export declare const findNextFocusableElement: (element: HTMLElement, findNextElementFn?: (element: HTMLElement) => HTMLElement | null) => HTMLElement | null;
+/**
+ * Finds the previous focusable element before the given one in document order.
+ *
+ * @param element - element to start from
+ * @param findPreviousElementFn - optional function to customize element traversal order (defaults to depth-first pre-order)
+ * @returns the previous focusable element, or null if none found.
+ */
+export declare const findPreviousFocusableElement: (element: HTMLElement, findPreviousElementFn?: (element: HTMLElement) => HTMLElement | null) => HTMLElement | null;