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

package/{alert-Db6cG6JE.js → alert-klFrSyNy.js}

@@ -71,6 +71,7 @@ const createExtendedAlert = extendWidgetProps(
   alertDefaultConfig,
   alertConfigValidator,
   {
+    dismissible: false,
     transition: alertFadeTransition
   }
 );

package/components/alert/alert.d.ts

@@ -74,6 +74,12 @@ export interface AlertState extends CommonAlertState, AlertExtraPropsAndState {
  * Represents the properties for the alert component.
  */
 export interface AlertProps extends CommonAlertProps, AlertExtraProps {
+    /**
+     * If `true`, alert can be dismissed by the user.
+     *
+     * @defaultValue `false`
+     */
+    dismissible: boolean;
 }
 /**
  * Represents the API for an alert component.

package/components/alert/index.js

@@ -1,4 +1,4 @@
-import { c } from "../../alert-Db6cG6JE.js";
+import { c } from "../../alert-klFrSyNy.js";
 export {
   c as createAlert
 };

package/components/dropdown/index.js

@@ -1,4 +1,4 @@
-import { c, g } from "../../dropdown-Bjj2ql6d.js";
+import { c, g } from "../../dropdown-BZiBfdNu.js";
 export {
   c as createDropdown,
   g as getDropdownDefaultConfig

package/components/tooltip/index.js

@@ -1,174 +1,6 @@
-import { writable, derived, computed, readable } from "@amadeus-it-group/tansu";
-import { createHasFocus, activeElement$ } from "../../services/focustrack.js";
-import { createHasMouseInside } from "../../services/mousetrack.js";
-import { typePlacement, createPositioning } from "../../services/positioning.js";
-import { createTransition } from "../../services/transitions/baseTransitions.js";
-import { createSimpleClassTransition } from "../../services/transitions/simpleClassTransition.js";
-import { debounceSignal } from "../../utils/debounceSignal.js";
-import { w as addEvent, s as mergeDirectives, g as createAttributesDirective, o as directiveSubscribe } from "../../directive-CMT2vEDg.js";
-import { createEdgeState } from "../../utils/edgeState.js";
-import { generateId } from "../../utils/id.js";
-import { writablesForProps, stateStores } from "../../utils/stores.js";
-import { createWidgetFactory } from "../../utils/widget.js";
-import { a as createTypeStringSpacedArray, d as typeBoolean, l as typeStringOrNull, c as createTypeEnum } from "../../writables-_7BriMb2.js";
-const verticalPlacement = ["top", "top-start", "top-end", "bottom", "bottom-start", "bottom-end"];
-const horizontalPlacement = ["end", "end-end", "end-start", "start", "start-end", "start-start"];
-const defaultPlacement = [...verticalPlacement, ...horizontalPlacement];
-const fadeTransition = createSimpleClassTransition({
-  animationPendingClasses: ["df-fade"],
-  animationPendingShowClasses: ["df-show"],
-  showClasses: ["df-show", "df-fade"],
-  hideClasses: ["df-hidden", "df-fade"]
-});
-const defaultTooltipConfig = {
-  animated: true,
-  content: "",
-  disabled: false,
-  placement: defaultPlacement,
-  size: "md"
-};
-const tooltipConfigValidator = {
-  animated: typeBoolean,
-  content: typeStringOrNull,
-  disabled: typeBoolean,
-  placement: createTypeStringSpacedArray((placement) => {
-    if (placement === "auto") {
-      return defaultPlacement;
-    } else if (placement === "vertical") {
-      return verticalPlacement;
-    } else if (placement === "horizontal") {
-      return horizontalPlacement;
-    }
-    return typePlacement.normalizeValue(placement);
-  }),
-  size: createTypeEnum(["sm", "md", "lg"])
-};
-const DEBOUNCE_DELAY = 200;
-const createTooltip = createWidgetFactory(
-  "tooltip",
-  (config) => {
-    const [{ placement$, animated$, disabled$, content$, ...stateProps }, patch] = writablesForProps(
-      defaultTooltipConfig,
-      config,
-      tooltipConfigValidator
-    );
-    const floating = createPositioning({
-      props: {
-        placement: placement$
-      }
-    });
-    const { directive: hasFocusDirective, hasFocus$ } = createHasFocus();
-    const forceVisibleOnFocus$ = writable(false);
-    const hasVisibleFocus$ = derived(
-      [hasFocus$, activeElement$, forceVisibleOnFocus$],
-      ([hasFocus, activeElement, forceVisibleOnFocus], set) => {
-        if (hasFocus) {
-          if (forceVisibleOnFocus || activeElement?.matches(":focus-visible")) {
-            set(true);
-          }
-        } else {
-          set(false);
-        }
-      },
-      false
-    );
-    const debouncedHasVisibleFocus$ = debounceSignal(hasVisibleFocus$, (value) => value ? DEBOUNCE_DELAY : -1);
-    const { directive: hasMouseInsideDirective, hasMouseInside$ } = createHasMouseInside();
-    const debouncedHasMouseInside$ = debounceSignal(hasMouseInside$, DEBOUNCE_DELAY);
-    const visible$ = createEdgeState(
-      {
-        mouseInside: debouncedHasMouseInside$,
-        hasVisibleFocus: debouncedHasVisibleFocus$
-      },
-      computed(() => disabled$() || !content$() || floating.stores.referenceHidden$())
-    );
-    const transition = createTransition({
-      props: {
-        transition: fadeTransition,
-        visible: visible$,
-        animated: animated$,
-        animatedOnInit: true
-      }
-    });
-    const escDismiss$ = readable(void 0, {
-      onUse: () => addEvent(
-        document.documentElement,
-        "keydown",
-        (event) => {
-          if (visible$() && event.key === "Escape") {
-            void transition.api.toggle(false);
-            event.preventDefault();
-            event.stopPropagation();
-          }
-        },
-        { capture: true }
-      )
-    });
-    const id$ = computed(generateId);
-    return {
-      ...stateStores({
-        ...stateProps,
-        content$,
-        animated$,
-        disabled$,
-        placement$,
-        visible$: transition.stores.visible$,
-        hidden$: transition.stores.hidden$
-      }),
-      patch,
-      api: {},
-      directives: {
-        referenceDirective: mergeDirectives(
-          floating.directives.referenceDirective,
-          hasFocusDirective,
-          hasMouseInsideDirective,
-          createAttributesDirective(() => ({
-            attributes: {
-              "aria-describedby": computed(() => transition.stores.hidden$() ? void 0 : id$())
-            },
-            styles: {
-              // prevents the trigger element from being selected when long-pressing on touch devices
-              userSelect: computed(() => disabled$() ? void 0 : "none")
-            },
-            events: {
-              contextmenu: (event) => {
-                if (event.pointerType === "touch" && !disabled$()) {
-                  event.preventDefault();
-                  if (hasVisibleFocus$()) {
-                    void transition.api.toggle(true);
-                  } else {
-                    forceVisibleOnFocus$.set(true);
-                    event.currentTarget?.focus?.();
-                    forceVisibleOnFocus$.set(false);
-                  }
-                }
-              }
-            }
-          }))
-        ),
-        floatingDirective: mergeDirectives(
-          floating.directives.floatingDirective,
-          transition.directives.directive,
-          hasMouseInsideDirective,
-          directiveSubscribe(escDismiss$),
-          createAttributesDirective(() => ({
-            attributes: {
-              role: readable("tooltip"),
-              id: id$
-            },
-            events: {
-              mousedown: (event) => {
-                if (hasVisibleFocus$() && debouncedHasMouseInside$() && !event.defaultPrevented) {
-                  visible$.skipNextSourceValue("hasVisibleFocus", false);
-                }
-              }
-            }
-          }))
-        )
-      }
-    };
-  }
-);
+import { c, d, t } from "../../tooltip-Cl7tQomt.js";
 export {
-  createTooltip
+  c as createTooltip,
+  d as defaultPlacement,
+  t as tooltipPlacementValidator
 };

package/components/tooltip/tooltip.d.ts

@@ -1,5 +1,5 @@
 import { type Placement } from '../../services/positioning';
-import type { Directive, SSRHTMLElement, Widget, WidgetFactory } from '../../types';
+import type { Directive, PickRequired, SSRHTMLElement, Widget, WidgetFactory, WritableWithDefaultOptions } from '../../types';
 /**
  * Valid placement values for the tooltip.
  * Includes all individual {@link Placement} values plus `'auto'`, `'vertical'` and `'horizontal'` shortcuts.
@@ -9,6 +9,10 @@ import type { Directive, SSRHTMLElement, Widget, WidgetFactory } from '../../typ
  * - `'horizontal'` expands to `'end end-end end-start start start-end start-start'`
  */
 export type TooltipPlacement = Placement | 'auto' | 'vertical' | 'horizontal';
+/**
+ * Default tooltip placements, in order of preference (vertical first, then horizontal).
+ */
+export declare const defaultPlacement: Placement[];
 export type TooltipSize = 'sm' | 'md' | 'lg';
 export interface TooltipCommonPropsAndState {
     /**
@@ -55,6 +59,11 @@ export interface TooltipDirectives {
     floatingDirective: Directive<void, SSRHTMLElement>;
 }
 export type TooltipWidget = Widget<TooltipProps, TooltipState, Record<string, never>, TooltipDirectives>;
+/**
+ * Validator for the tooltip `placement` prop. Normalizes a space-separated string or array of placements, expanding the
+ * `'auto'`, `'vertical'` and `'horizontal'` shortcuts to their respective placement lists.
+ */
+export declare const tooltipPlacementValidator: PickRequired<WritableWithDefaultOptions<Placement[]>, 'normalizeValue' | 'equal'>;
 /**
  * Create a TooltipWidget with given config props
  * @param config - an optional tooltip config

package/components/tooltip-overflow/index.d.ts

@@ -0,0 +1 @@
+export * from './tooltip-overflow';

package/components/tooltip-overflow/index.js

@@ -0,0 +1,78 @@
+import { derived, computed, asWritable } from "@amadeus-it-group/tansu";
+import { createResizeObserver } from "../../services/resizeObserver.js";
+import { i as createBrowserStoreDirective, s as mergeDirectives } from "../../directive-CMT2vEDg.js";
+import { noop } from "../../utils/func.js";
+import { writablesForProps, stateStores } from "../../utils/stores.js";
+import { createWidgetFactory } from "../../utils/widget.js";
+import { k as typeString, l as typeStringOrNull, d as typeBoolean, c as createTypeEnum } from "../../writables-_7BriMb2.js";
+import { t as tooltipPlacementValidator, d as defaultPlacement } from "../../tooltip-Cl7tQomt.js";
+const defaultOverflowTooltipConfig = {
+  animated: true,
+  content: "",
+  placement: defaultPlacement,
+  size: "md",
+  iconAriaLabel: "Show full text"
+};
+const overflowTooltipConfigValidator = {
+  animated: typeBoolean,
+  content: typeStringOrNull,
+  placement: tooltipPlacementValidator,
+  size: createTypeEnum(["sm", "md", "lg"]),
+  iconAriaLabel: typeString
+};
+const createOverflowTooltip = createWidgetFactory(
+  "tooltip",
+  // reuses the same config as the tooltip widget
+  (config) => {
+    const [{ content$, ...stateProps }, patch] = writablesForProps(
+      defaultOverflowTooltipConfig,
+      config,
+      overflowTooltipConfigValidator
+    );
+    const { directive: elementDirective, element$ } = createBrowserStoreDirective();
+    const textContent$ = derived(
+      element$,
+      (el, set) => {
+        if (!el) {
+          set("");
+          return noop;
+        }
+        set(el.textContent?.trim() ?? "");
+        const observer = new MutationObserver(() => set(el.textContent?.trim() ?? ""));
+        observer.observe(el, { childList: true, characterData: true, subtree: true });
+        return () => observer.disconnect();
+      },
+      ""
+    );
+    const { directive: resizeDirective, dimensions$ } = createResizeObserver();
+    const overflowing$ = computed(() => {
+      dimensions$();
+      textContent$();
+      const el = element$();
+      if (!el) {
+        return false;
+      }
+      return el.offsetWidth < el.scrollWidth;
+    });
+    const resolvedContent$ = asWritable(
+      computed(() => content$() || textContent$()),
+      content$.set
+    );
+    const referenceDirective = mergeDirectives(elementDirective, resizeDirective);
+    return {
+      ...stateStores({
+        ...stateProps,
+        content$: resolvedContent$,
+        overflowing$
+      }),
+      patch,
+      api: {},
+      directives: {
+        referenceDirective
+      }
+    };
+  }
+);
+export {
+  createOverflowTooltip
+};

package/components/tooltip-overflow/tooltip-overflow.d.ts

@@ -0,0 +1,34 @@
+import type { Directive, Widget, WidgetFactory } from '../../types';
+import { TooltipCommonPropsAndState } from '../tooltip/tooltip';
+export interface OverflowTooltipCommonPropsAndState extends Omit<TooltipCommonPropsAndState, 'disabled'> {
+    /**
+     * Text content to be displayed inside the tooltip.
+     * When empty, defaults to the element's textContent.
+     */
+    content: string | null;
+    /**
+     * Aria label for the tooltip ellipsis icon.
+     */
+    iconAriaLabel: string;
+}
+export interface OverflowTooltipState extends OverflowTooltipCommonPropsAndState {
+    /**
+     * Whether the element is currently overflowing.
+     */
+    overflowing: boolean;
+}
+export interface OverflowTooltipProps extends OverflowTooltipCommonPropsAndState {
+}
+export interface OverflowTooltipDirectives {
+    /**
+     * Directive to apply to the reference element.
+     */
+    referenceDirective: Directive;
+}
+export type OverflowTooltipWidget = Widget<OverflowTooltipProps, OverflowTooltipState, Record<string, never>, OverflowTooltipDirectives>;
+/**
+ * Create a OverflowTooltipWidget with given config props
+ * @param config - an optional overflow-tooltip config
+ * @returns a OverflowTooltipWidget
+ */
+export declare const createOverflowTooltip: WidgetFactory<OverflowTooltipWidget>;

package/{dropdown-Bjj2ql6d.js → dropdown-BZiBfdNu.js}

@@ -1,8 +1,8 @@
-import { computed, readable, derived } from "@amadeus-it-group/tansu";
+import { computed, readable } from "@amadeus-it-group/tansu";
 import { createHasFocus } from "./services/focustrack.js";
 import { createNavManager } from "./services/navManager.js";
 import { typePlacementArray, createPositioning } from "./services/positioning.js";
-import { s as mergeDirectives, g as createAttributesDirective, d as browserDirective, o as directiveSubscribe, b as bindDirective } from "./directive-CMT2vEDg.js";
+import { s as mergeDirectives, g as createAttributesDirective, d as browserDirective, b as bindDirective, w as addEvent } from "./directive-CMT2vEDg.js";
 import { noop } from "./utils/func.js";
 import { generateId } from "./utils/id.js";
 import { i as isFocusable, f as findPreviousFocusableElement, a as findNextFocusableElement, b as findNextElementSkippingSubtree, c as findNextElement } from "./isFocusable-C2iRr0zh.js";
@@ -83,11 +83,6 @@ const createDropdown = createWidgetFactory(
         End: ({ event }) => {
           event.preventDefault();
           focusLast({ event });
-        },
-        Escape: ({ event }) => {
-          event.preventDefault();
-          toggle(false);
-          anchorElement?.focus();
         }
       },
       selector: (menuElement) => menuElement.querySelectorAll(menuItemSelector)
@@ -100,18 +95,54 @@ const createDropdown = createWidgetFactory(
     });
     const positioningBeforeRef$ = computed(() => positioning.stores.placement$()?.startsWith("top"));
     const { directive: hasFocusDirective, hasFocus$ } = createHasFocus();
-    let previousHasFocus = false;
-    const autoClose$ = derived(hasFocus$, (hasFocus) => {
-      if (previousHasFocus && !hasFocus) {
-        toggle(false);
-      }
-      previousHasFocus = hasFocus;
-    });
     function toggle(opened) {
       opened$.update((currentOpened) => {
         return opened !== void 0 ? opened : !currentOpened;
       });
     }
+    const menuDismissDirective = browserDirective((menuElement) => {
+      let hadFocus = hasFocus$();
+      const unsubscribeFocus = hasFocus$.subscribe((hasFocus) => {
+        if (hadFocus && !hasFocus) {
+          toggle(false);
+        }
+        hadFocus = hasFocus;
+      });
+      const isInsideDropdown = (event) => {
+        const eventPath = event.composedPath();
+        return eventPath.includes(menuElement) || !!anchorElement && eventPath.includes(anchorElement);
+      };
+      const removeClickEvent = addEvent(
+        document.documentElement,
+        "click",
+        (event) => {
+          if (opened$() && !isInsideDropdown(event)) {
+            toggle(false);
+          }
+        },
+        { capture: true }
+      );
+      const removeKeydownEvent = addEvent(
+        document.documentElement,
+        "keydown",
+        (event) => {
+          if (opened$() && event.key === "Escape") {
+            toggle(false);
+            anchorElement?.focus();
+            event.preventDefault();
+            event.stopPropagation();
+          }
+        },
+        { capture: true }
+      );
+      return {
+        destroy: () => {
+          unsubscribeFocus();
+          removeClickEvent();
+          removeKeydownEvent();
+        }
+      };
+    });
     const menuIdIfNeeded$ = computed(() => opened$() && container$() === "body" ? menuId$() : void 0);
     const idIfOpen$ = computed(() => opened$() ? id$() : void 0);
     return {
@@ -127,7 +158,7 @@ const createDropdown = createWidgetFactory(
           positioning.directives.floatingDirective,
           bindDirective(navDirective, navManagerConfig$),
           hasFocusDirective,
-          directiveSubscribe(autoClose$),
+          menuDismissDirective,
           createAttributesDirective(() => ({
             events: {
               // Clicking a non-interactive region of the menu (separator, padding, headers, aria-disabled items)
@@ -200,9 +231,6 @@ const createDropdown = createWidgetFactory(
                     event.preventDefault();
                     refreshElements(true);
                     focusLast();
-                  } else if (key === "Escape") {
-                    event.preventDefault();
-                    toggle(false);
                   } else if (key === "Tab") {
                     const before = positioningBeforeRef$();
                     if (!!event.shiftKey === before) {

package/index.js

@@ -1,8 +1,8 @@
 import { FACTORY_WIDGET_NAME, INVALID_VALUE } from "./types.js";
 import { c, a, f, g } from "./accordion-DUFLBQkV.js";
-import { c as c2 } from "./alert-Db6cG6JE.js";
+import { c as c2 } from "./alert-klFrSyNy.js";
 import { c as c3, g as g2 } from "./collapse-D8Jo56k9.js";
-import { c as c4, g as g3 } from "./dropdown-Bjj2ql6d.js";
+import { c as c4, g as g3 } from "./dropdown-BZiBfdNu.js";
 import { c as c5, g as g4, m, a as a2, b } from "./modal-CQWh2Sm5.js";
 import { c as c6, g as g5 } from "./pagination-DIRcpdRE.js";
 import { c as c7, g as g6 } from "./progressbar-Bth8r3Qu.js";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@design-factory/core",
 	"description": "Internal package used by the Design Factory.",
-	"version": "22.0.0-next.1",
+	"version": "22.0.0",
 	"type": "module",
 	"main": "./index.cjs",
 	"module": "./index.js",

package/tooltip-Cl7tQomt.js

@@ -0,0 +1,177 @@
+import { writable, derived, computed, readable } from "@amadeus-it-group/tansu";
+import { createHasFocus, activeElement$ } from "./services/focustrack.js";
+import { createHasMouseInside } from "./services/mousetrack.js";
+import { typePlacement, createPositioning } from "./services/positioning.js";
+import { createTransition } from "./services/transitions/baseTransitions.js";
+import { createSimpleClassTransition } from "./services/transitions/simpleClassTransition.js";
+import { debounceSignal } from "./utils/debounceSignal.js";
+import { w as addEvent, s as mergeDirectives, g as createAttributesDirective, o as directiveSubscribe } from "./directive-CMT2vEDg.js";
+import { createEdgeState } from "./utils/edgeState.js";
+import { generateId } from "./utils/id.js";
+import { writablesForProps, stateStores } from "./utils/stores.js";
+import { createWidgetFactory } from "./utils/widget.js";
+import { a as createTypeStringSpacedArray, d as typeBoolean, l as typeStringOrNull, c as createTypeEnum } from "./writables-_7BriMb2.js";
+const verticalPlacement = ["top", "top-start", "top-end", "bottom", "bottom-start", "bottom-end"];
+const horizontalPlacement = ["end", "end-end", "end-start", "start", "start-end", "start-start"];
+const defaultPlacement = [...verticalPlacement, ...horizontalPlacement];
+const fadeTransition = createSimpleClassTransition({
+  animationPendingClasses: ["df-fade"],
+  animationPendingShowClasses: ["df-show"],
+  showClasses: ["df-show", "df-fade"],
+  hideClasses: ["df-hidden", "df-fade"]
+});
+const defaultTooltipConfig = {
+  animated: true,
+  content: "",
+  disabled: false,
+  placement: defaultPlacement,
+  size: "md"
+};
+const tooltipPlacementValidator = createTypeStringSpacedArray((placement) => {
+  if (placement === "auto") {
+    return defaultPlacement;
+  } else if (placement === "vertical") {
+    return verticalPlacement;
+  } else if (placement === "horizontal") {
+    return horizontalPlacement;
+  }
+  return typePlacement.normalizeValue(placement);
+});
+const tooltipConfigValidator = {
+  animated: typeBoolean,
+  content: typeStringOrNull,
+  disabled: typeBoolean,
+  placement: tooltipPlacementValidator,
+  size: createTypeEnum(["sm", "md", "lg"])
+};
+const DEBOUNCE_DELAY = 200;
+const createTooltip = createWidgetFactory(
+  "tooltip",
+  (config) => {
+    const [{ placement$, animated$, disabled$, content$, ...stateProps }, patch] = writablesForProps(
+      defaultTooltipConfig,
+      config,
+      tooltipConfigValidator
+    );
+    const floating = createPositioning({
+      props: {
+        placement: placement$
+      }
+    });
+    const { directive: hasFocusDirective, hasFocus$ } = createHasFocus();
+    const forceVisibleOnFocus$ = writable(false);
+    const hasVisibleFocus$ = derived(
+      [hasFocus$, activeElement$, forceVisibleOnFocus$],
+      ([hasFocus, activeElement, forceVisibleOnFocus], set) => {
+        if (hasFocus) {
+          if (forceVisibleOnFocus || activeElement?.matches(":focus-visible")) {
+            set(true);
+          }
+        } else {
+          set(false);
+        }
+      },
+      false
+    );
+    const debouncedHasVisibleFocus$ = debounceSignal(hasVisibleFocus$, (value) => value ? DEBOUNCE_DELAY : -1);
+    const { directive: hasMouseInsideDirective, hasMouseInside$ } = createHasMouseInside();
+    const debouncedHasMouseInside$ = debounceSignal(hasMouseInside$, DEBOUNCE_DELAY);
+    const visible$ = createEdgeState(
+      {
+        mouseInside: debouncedHasMouseInside$,
+        hasVisibleFocus: debouncedHasVisibleFocus$
+      },
+      computed(() => disabled$() || !content$() || floating.stores.referenceHidden$())
+    );
+    const transition = createTransition({
+      props: {
+        transition: fadeTransition,
+        visible: visible$,
+        animated: animated$,
+        animatedOnInit: true
+      }
+    });
+    const escDismiss$ = readable(void 0, {
+      onUse: () => addEvent(
+        document.documentElement,
+        "keydown",
+        (event) => {
+          if (visible$() && event.key === "Escape") {
+            void transition.api.toggle(false);
+            event.preventDefault();
+            event.stopPropagation();
+          }
+        },
+        { capture: true }
+      )
+    });
+    const id$ = computed(generateId);
+    return {
+      ...stateStores({
+        ...stateProps,
+        content$,
+        animated$,
+        disabled$,
+        placement$,
+        visible$: transition.stores.visible$,
+        hidden$: transition.stores.hidden$
+      }),
+      patch,
+      api: {},
+      directives: {
+        referenceDirective: mergeDirectives(
+          floating.directives.referenceDirective,
+          hasFocusDirective,
+          hasMouseInsideDirective,
+          createAttributesDirective(() => ({
+            attributes: {
+              "aria-describedby": computed(() => transition.stores.hidden$() ? void 0 : id$())
+            },
+            styles: {
+              // prevents the trigger element from being selected when long-pressing on touch devices
+              userSelect: computed(() => disabled$() ? void 0 : "none")
+            },
+            events: {
+              contextmenu: (event) => {
+                if (event.pointerType === "touch" && !disabled$()) {
+                  event.preventDefault();
+                  if (hasVisibleFocus$()) {
+                    void transition.api.toggle(true);
+                  } else {
+                    forceVisibleOnFocus$.set(true);
+                    event.currentTarget?.focus?.();
+                    forceVisibleOnFocus$.set(false);
+                  }
+                }
+              }
+            }
+          }))
+        ),
+        floatingDirective: mergeDirectives(
+          floating.directives.floatingDirective,
+          transition.directives.directive,
+          hasMouseInsideDirective,
+          directiveSubscribe(escDismiss$),
+          createAttributesDirective(() => ({
+            attributes: {
+              role: readable("tooltip"),
+              id: id$
+            },
+            events: {
+              mousedown: (event) => {
+                if (hasVisibleFocus$() && debouncedHasMouseInside$() && !event.defaultPrevented) {
+                  visible$.skipNextSourceValue("hasVisibleFocus", false);
+                }
+              }
+            }
+          }))
+        )
+      }
+    };
+  }
+);
+export {
+  createTooltip as c,
+  defaultPlacement as d,
+  tooltipPlacementValidator as t
+};