@pzerelles/headlessui-svelte 2.1.1-next.1 → 2.1.2-next.11

package/dist/utils/ElementOrComponent.svelte.d.ts

@@ -0,0 +1,56 @@
+import type { ElementType } from "./types.js";
+import { RenderFeatures } from "./render.js";
+declare class __sveltets_Render<TFeature extends RenderFeatures, TTag extends ElementType, TSlot, TValue> {
+    props(): {
+        ourProps?: Expand<{
+            [x: string]: any;
+            [x: number]: any;
+        } & {
+            children?: import("./types.js").Children<TSlot> | undefined;
+            ref?: HTMLElement;
+        } & {
+            class?: any;
+        } & Expand<((TFeature extends RenderFeatures.Static ? {
+            static?: boolean;
+        } : {}) extends infer T ? T extends (TFeature extends RenderFeatures.Static ? {
+            static?: boolean;
+        } : {}) ? T extends any ? (x: T) => any : never : never : never) | ((TFeature extends RenderFeatures.RenderStrategy ? {
+            unmount?: boolean;
+        } : {}) extends infer T_1 ? T_1 extends (TFeature extends RenderFeatures.RenderStrategy ? {
+            unmount?: boolean;
+        } : {}) ? T_1 extends any ? (x: T_1) => any : never : never : never) extends (x: infer R) => any ? R : never>> | undefined;
+        theirProps: {
+            as?: TTag | undefined;
+            children?: import("./types.js").Children<TSlot> | undefined;
+            ref?: HTMLElement | undefined;
+            class?: any;
+        };
+        slot?: TSlot | undefined;
+        slots?: TSlot | undefined;
+        defaultTag: ElementType;
+        features?: TFeature | undefined;
+        visible?: boolean;
+        name: string;
+        ref?: HTMLElement;
+        value?: TValue | undefined;
+        checked?: boolean;
+    };
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "ref" | "value" | "checked";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TFeature extends RenderFeatures, TTag extends ElementType, TSlot, TValue>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['props']>, ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['events']>, ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['bindings']>;
+    } & ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['exports']>;
+    <TFeature extends RenderFeatures, TTag extends ElementType, TSlot, TValue>(internal: unknown, props: ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['props']> & {
+        $$events?: ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['events']>;
+    }): ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any, any, any>['bindings']>;
+}
+declare const ElementOrComponent: $$IsomorphicComponent;
+type ElementOrComponent<TFeature extends RenderFeatures, TTag extends ElementType, TSlot, TValue> = InstanceType<typeof ElementOrComponent<TFeature, TTag, TSlot, TValue>>;
+export default ElementOrComponent;

package/dist/utils/Generic.svelte

@@ -0,0 +1,44 @@
+<script lang="ts" generics="TTag extends keyof SvelteHTMLProps, TSlot, TValue">import { stateFromSlot } from "./state.js";
+let {
+  slot = {},
+  tag,
+  name,
+  ref = $bindable(),
+  value = $bindable(),
+  checked = $bindable(),
+  children,
+  as = tag,
+  unmount,
+  static: isStatic,
+  ...props
+} = $props();
+const resolvedClass = $derived(
+  typeof props.class === "function" ? props.class(slot) : props.class
+);
+</script>
+
+{#if as === "svelte:fragment"}
+  {#if children}{@render children(slot, {
+      ...props,
+      ...(resolvedClass ? { class: resolvedClass } : {}),
+      ...stateFromSlot(slot),
+    })}{/if}
+{:else if children}
+  {#if as === "select"}
+    <select bind:this={ref} {...props} class={resolvedClass} {...stateFromSlot(slot)} bind:value>
+      {@render children(slot, {})}
+    </select>
+  {:else}
+    <svelte:element this={as} bind:this={ref} {...props} class={resolvedClass} {...stateFromSlot(slot)}>
+      {@render children(slot, {})}
+    </svelte:element>
+  {/if}
+{:else if as === "input" && props.type === "checkbox"}
+  <input type="checkbox" bind:this={ref} {...props} class={resolvedClass} {...stateFromSlot(slot)} bind:checked />
+{:else if as === "input"}
+  <input bind:this={ref} {...props} class={resolvedClass} {...stateFromSlot(slot)} bind:value />
+{:else if as === "textarea"}
+  <textarea bind:this={ref} {...props} class={resolvedClass} {...stateFromSlot(slot)} bind:value></textarea>
+{:else}
+  <svelte:element this={as} bind:this={ref} {...props} class={resolvedClass} {...stateFromSlot(slot)} />
+{/if}

package/dist/utils/Generic.svelte.d.ts

@@ -0,0 +1,35 @@
+import type { ElementType, SvelteHTMLProps } from "./types.js";
+declare class __sveltets_Render<TTag extends keyof SvelteHTMLProps, TSlot, TValue> {
+    props(): {
+        as?: TTag | undefined;
+        slot: TSlot;
+        tag: ElementType;
+        name: string;
+        ref?: HTMLElement;
+        value?: TValue | undefined;
+        checked?: boolean;
+    } & (Exclude<keyof import("./types.js").PropsOf<TTag>, "as" | "children" | "refName" | "class"> extends infer T extends keyof import("./types.js").PropsOf<TTag> ? { [P in T]: import("./types.js").PropsOf<TTag>[P]; } : never) & {
+        children?: import("./types.js").Children<TSlot> | undefined;
+        ref?: HTMLElement;
+    } & (true extends (import("./types.js").PropsOf<TTag> extends infer T_1 ? T_1 extends import("./types.js").PropsOf<TTag> ? T_1 extends never ? never : "class" extends infer T_2 ? T_2 extends "class" ? T_2 extends keyof T_1 ? true : never : never : never : never : never) ? {
+        class?: import("./types.js").PropsOf<TTag>["class"] | ((bag: TSlot) => string) | undefined;
+    } : {});
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "ref" | "value" | "checked";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TTag extends keyof SvelteHTMLProps, TSlot, TValue>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TTag, TSlot, TValue>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TTag, TSlot, TValue>['props']>, ReturnType<__sveltets_Render<TTag, TSlot, TValue>['events']>, ReturnType<__sveltets_Render<TTag, TSlot, TValue>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TTag, TSlot, TValue>['bindings']>;
+    } & ReturnType<__sveltets_Render<TTag, TSlot, TValue>['exports']>;
+    <TTag extends keyof SvelteHTMLProps, TSlot, TValue>(internal: unknown, props: ReturnType<__sveltets_Render<TTag, TSlot, TValue>['props']> & {
+        $$events?: ReturnType<__sveltets_Render<TTag, TSlot, TValue>['events']>;
+    }): ReturnType<__sveltets_Render<TTag, TSlot, TValue>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any, any>['bindings']>;
+}
+declare const Generic: $$IsomorphicComponent;
+type Generic<TTag extends keyof SvelteHTMLProps, TSlot, TValue> = InstanceType<typeof Generic<TTag, TSlot, TValue>>;
+export default Generic;

package/dist/utils/StableCollection.svelte

@@ -1,4 +1,4 @@
-<script lang="ts" context="module">import { useId } from "../hooks/use-id.js";
+<script lang="ts" module>import { useId } from "../hooks/use-id.js";
 import { getContext, setContext } from "svelte";
 function createCollection() {
   return {

package/dist/utils/StableCollection.svelte.d.ts

@@ -7,7 +7,10 @@ interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> =
     (internal: unknown, props: Props & {
         $$events?: Events;
         $$slots?: Slots;
-    }): Exports;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
     z_$$bindings?: Bindings;
 }
 declare const StableCollection: $$__sveltets_2_IsomorphicComponent<{

package/dist/utils/active-element-history.d.ts

@@ -0,0 +1 @@
+export declare let history: HTMLElement[];

package/dist/utils/active-element-history.js

@@ -0,0 +1,35 @@
+import { focusableSelector } from "./focus-management.js";
+import { onDocumentReady } from "./on-document-ready.js";
+export let history = [];
+onDocumentReady(() => {
+    function handle(e) {
+        if (!(e.target instanceof HTMLElement))
+            return;
+        if (e.target === document.body)
+            return;
+        if (history[0] === e.target)
+            return;
+        let focusableElement = e.target;
+        // Figure out the closest focusable element, this is needed in a situation
+        // where you click on a non-focusable element inside a focusable element.
+        //
+        // E.g.:
+        //
+        // ```html
+        // <button>
+        //   <span>Click me</span>
+        // </button>
+        // ```
+        focusableElement = focusableElement.closest(focusableSelector);
+        history.unshift(focusableElement ?? e.target);
+        // Filter out DOM Nodes that don't exist anymore
+        history = history.filter((x) => x != null && x.isConnected);
+        history.splice(10); // Only keep the 10 most recent items
+    }
+    window.addEventListener("click", handle, { capture: true });
+    window.addEventListener("mousedown", handle, { capture: true });
+    window.addEventListener("focus", handle, { capture: true });
+    document.body.addEventListener("click", handle, { capture: true });
+    document.body.addEventListener("mousedown", handle, { capture: true });
+    document.body.addEventListener("focus", handle, { capture: true });
+});

package/dist/utils/alternative-types.d.ts

@@ -0,0 +1,21 @@
+import type { Snippet } from "svelte";
+import type { SvelteHTMLElements } from "svelte/elements";
+export interface SvelteHTMLProps extends SvelteHTMLElements {
+    "svelte:fragment": {};
+}
+export type ElementType = keyof SvelteHTMLProps;
+export type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+export type Children<TSlot> = Snippet | Snippet<[TSlot, Record<string, any>]>;
+type OurProps<TSlot> = {
+    children?: Children<TSlot>;
+    ref?: HTMLElement;
+    class?: string | null | ((bag: TSlot) => string);
+};
+type MergeProps3<T, U, V> = {
+    [K in keyof T | keyof U | keyof V]?: K extends keyof V ? V[K] : K extends keyof U ? U[K] : K extends keyof T ? T[K] : never;
+};
+export type Props<TTag extends ElementType, TSlot = {}, TOmittableProps extends PropertyKey = never, Overrides = {}> = MergeProps3<SvelteHTMLProps[TTag], OurProps<TSlot>, Overrides>;
+export type EnsureArray<T> = T extends any[] ? T : Expand<T>[];
+export {};

package/dist/utils/alternative-types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/class-names.d.ts

@@ -0,0 +1 @@
+export declare function classNames(...classes: (false | null | undefined | string)[]): string;

package/dist/utils/class-names.js

@@ -0,0 +1,10 @@
+export function classNames(...classes) {
+    return Array.from(new Set(classes.flatMap((value) => {
+        if (typeof value === "string") {
+            return value.split(" ");
+        }
+        return [];
+    })))
+        .filter(Boolean)
+        .join(" ");
+}

package/dist/utils/floating-ui/svelte/components/FloatingNode.svelte

@@ -0,0 +1,17 @@
+<script lang="ts" module></script>
+
+<script lang="ts">import { setContext } from "svelte";
+import { useFloatingParentNodeId } from "./FloatingTree.svelte";
+const { children, id } = $props();
+const parentId = useFloatingParentNodeId();
+setContext("FloatingNodeContext", {
+  get id() {
+    return id;
+  },
+  get parentId() {
+    return parentId.value;
+  }
+});
+</script>
+
+{#if children}{@render children()}{/if}

package/dist/utils/floating-ui/svelte/components/FloatingNode.svelte.d.ts

@@ -0,0 +1,23 @@
+import type { Snippet } from "svelte";
+export interface FloatingNodeProps {
+    children?: Snippet;
+    id: string;
+}
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const FloatingNode: $$__sveltets_2_IsomorphicComponent<FloatingNodeProps, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, "">;
+type FloatingNode = InstanceType<typeof FloatingNode>;
+export default FloatingNode;

package/dist/utils/floating-ui/svelte/components/FloatingTree.svelte

@@ -0,0 +1,50 @@
+<script lang="ts" module>import { getContext } from "svelte";
+import { useId } from "../hooks/useId.svelte.js";
+import { createPubSub } from "../utils/createPubSub.js";
+export const useFloatingParentNodeId = () => {
+  const context = getContext("FloatingNodeContext");
+  return {
+    get value() {
+      return context?.id ?? null;
+    }
+  };
+};
+export const useFloatingTree = () => getContext("FloatingTreeContext") ?? null;
+export function useFloatingNodeId(options) {
+  const { customParentId } = $derived(options);
+  const id = useId();
+  const tree = useFloatingTree();
+  const reactParentId = useFloatingParentNodeId();
+  const parentId = $derived(customParentId || reactParentId.value);
+  $effect(() => {
+    const node = { id, parentId };
+    tree?.addNode(node);
+    return () => {
+      tree?.removeNode(node);
+    };
+  });
+  return id;
+}
+</script>
+
+<script lang="ts">import { setContext } from "svelte";
+const { children } = $props();
+const nodesRef = $state({ current: [] });
+const addNode = (node) => {
+  nodesRef.current = [...nodesRef.current, node];
+};
+const removeNode = (node) => {
+  nodesRef.current = nodesRef.current.filter((n) => n !== node);
+};
+const events = createPubSub();
+setContext("FloatingTreeContext", {
+  get nodesRef() {
+    return nodesRef;
+  },
+  addNode,
+  removeNode,
+  events
+});
+</script>
+
+{#if children}{@render children()}{/if}

package/dist/utils/floating-ui/svelte/components/FloatingTree.svelte.d.ts

@@ -0,0 +1,41 @@
+import { type Snippet } from "svelte";
+import type { FloatingTreeType, ReferenceType } from "../types.js";
+/**
+ * Returns the parent node id for nested floating elements, if available.
+ * Returns `null` for top-level floating elements.
+ */
+export declare const useFloatingParentNodeId: () => {
+    readonly value: string | null;
+};
+/**
+ * Returns the nearest floating tree context, if available.
+ */
+export declare const useFloatingTree: <RT extends ReferenceType = ReferenceType>() => FloatingTreeType<RT> | null;
+/**
+ * Registers a node into the `FloatingTree`, returning its id.
+ * @see https://floating-ui.com/docs/FloatingTree
+ */
+export declare function useFloatingNodeId(options: {
+    customParentId?: string;
+}): string;
+export interface FloatingTreeProps {
+    children?: Snippet;
+}
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const FloatingTree: $$__sveltets_2_IsomorphicComponent<FloatingTreeProps, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, "">;
+type FloatingTree = InstanceType<typeof FloatingTree>;
+export default FloatingTree;

package/dist/utils/floating-ui/svelte/hooks/useFloating.svelte.d.ts

@@ -0,0 +1,6 @@
+import type { ReferenceType, UseFloatingOptions, UseFloatingReturn } from "../types.js";
+/**
+ * Provides data to position a floating element and context to add interactions.
+ * @see https://floating-ui.com/docs/useFloating
+ */
+export declare function useFloating<RT extends ReferenceType = ReferenceType>(options?: UseFloatingOptions): UseFloatingReturn<RT>;

package/dist/utils/floating-ui/svelte/hooks/useFloating.svelte.js

@@ -0,0 +1,158 @@
+import { useFloating as usePosition } from "../../svelte-dom/index.js";
+import { isElement } from "@floating-ui/utils/dom";
+import { useFloatingTree } from "../components/FloatingTree.svelte";
+import { useFloatingRootContext } from "./useFloatingRootContext.svelte.js";
+/**
+ * Provides data to position a floating element and context to add interactions.
+ * @see https://floating-ui.com/docs/useFloating
+ */
+export function useFloating(options = {}) {
+    const { nodeId } = $derived(options);
+    const internalRootContext = useFloatingRootContext({
+        get open() {
+            return options.open;
+        },
+        get onOpenChange() {
+            return options.onOpenChange;
+        },
+        get elements() {
+            return {
+                reference: null,
+                floating: null,
+                ...options.elements,
+            };
+        },
+    });
+    const rootContext = $derived(options.rootContext || internalRootContext);
+    const computedElements = $derived(rootContext.elements);
+    let _domReference = $state(null);
+    const setDomReference = (value) => (_domReference = value);
+    let positionReference = $state(null);
+    const _setPositionReference = (value) => (positionReference = value);
+    const optionDomReference = $derived(computedElements?.reference);
+    const domReference = $derived((optionDomReference || _domReference));
+    const domReferenceRef = $state({ current: null });
+    const tree = useFloatingTree();
+    $effect(() => {
+        if (domReference) {
+            domReferenceRef.current = domReference;
+        }
+    });
+    const position = usePosition({
+        get placement() {
+            return options.placement;
+        },
+        get strategy() {
+            return options.strategy;
+        },
+        get middleware() {
+            return options.middleware;
+        },
+        get platform() {
+            return options.platform;
+        },
+        get whileElementsMounted() {
+            return options.whileElementsMounted;
+        },
+        get open() {
+            return options.open;
+        },
+        get transform() {
+            return options.transform;
+        },
+        get elements() {
+            return {
+                ...computedElements,
+                ...(positionReference && { reference: positionReference }),
+            };
+        },
+    });
+    const setPositionReference = (node) => {
+        const computedPositionReference = isElement(node)
+            ? {
+                getBoundingClientRect: () => node.getBoundingClientRect(),
+                contextElement: node,
+            }
+            : node;
+        // Store the positionReference in state if the DOM reference is specified externally via the
+        // `elements.reference` option. This ensures that it won't be overridden on future renders.
+        _setPositionReference(computedPositionReference);
+        position.refs.setReference(computedPositionReference);
+    };
+    const setReference = (node) => {
+        if (isElement(node) || node === null) {
+            ;
+            domReferenceRef.current = node;
+            setDomReference(node);
+        }
+        // Backwards-compatibility for passing a virtual element to `reference`
+        // after it has set the DOM reference.
+        if (isElement(position.refs.reference.current) ||
+            position.refs.reference.current === null ||
+            // Don't allow setting virtual elements using the old technique back to
+            // `null` to support `positionReference` + an unstable `reference`
+            // callback ref.
+            (node !== null && !isElement(node))) {
+            position.refs.setReference(node);
+        }
+    };
+    const refs = $derived({
+        ...position.refs,
+        setReference,
+        setPositionReference,
+        domReference: domReferenceRef,
+    });
+    const elements = $derived({
+        ...position.elements,
+        domReference: domReference,
+    });
+    const context = $derived({
+        ...position,
+        ...rootContext,
+        refs,
+        elements,
+        nodeId,
+    });
+    $effect(() => {
+        rootContext.dataRef.current.floatingContext = context;
+        const node = tree?.nodesRef.current.find((node) => node.id === nodeId);
+        if (node) {
+            node.context = context;
+        }
+    });
+    return {
+        get placement() {
+            return position.placement;
+        },
+        get strategy() {
+            return position.strategy;
+        },
+        get middlewareData() {
+            return position.middlewareData;
+        },
+        get x() {
+            return position.x;
+        },
+        get y() {
+            return position.y;
+        },
+        get isPositioned() {
+            return position.isPositioned;
+        },
+        get update() {
+            return position.update;
+        },
+        get floatingStyles() {
+            return position.floatingStyles;
+        },
+        get context() {
+            return context;
+        },
+        get refs() {
+            return refs;
+        },
+        get elements() {
+            return elements;
+        },
+    };
+}

package/dist/utils/floating-ui/svelte/hooks/useFloatingRootContext.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { FloatingRootContext } from "../types.js";
+import type { OpenChangeReason } from "../types.js";
+export interface UseFloatingRootContextOptions {
+    open?: boolean;
+    onOpenChange?: (open: boolean, event?: Event, reason?: OpenChangeReason) => void;
+    elements: {
+        reference: Element | null;
+        floating: HTMLElement | null;
+    };
+}
+export declare function useFloatingRootContext(options: UseFloatingRootContextOptions): FloatingRootContext;

package/dist/utils/floating-ui/svelte/hooks/useFloatingRootContext.svelte.js

@@ -0,0 +1,53 @@
+import { isElement } from "@floating-ui/utils/dom";
+//import { useEffectEvent } from "./utils/useEffectEvent"
+import { createPubSub } from "../utils/createPubSub.js";
+import { useId } from "./useId.svelte.js";
+import { useFloatingParentNodeId } from "../components/FloatingTree.svelte";
+import { error } from "../utils/log.js";
+import { DEV } from "esm-env";
+export function useFloatingRootContext(options) {
+    const { open = false, onOpenChange: onOpenChangeProp, elements: elementsProp } = options;
+    const floatingId = useId();
+    const dataRef = $state({ current: {} });
+    const events = createPubSub();
+    const nested = useFloatingParentNodeId() != null;
+    if (DEV) {
+        const optionDomReference = elementsProp.reference;
+        if (optionDomReference && !isElement(optionDomReference)) {
+            error("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
+        }
+    }
+    let positionReference = $state(elementsProp.reference);
+    const onOpenChange = (open, event, reason) => {
+        dataRef.current.openEvent = open ? event : undefined;
+        events.emit("openchange", { open, event, reason, nested });
+        onOpenChangeProp?.(open, event, reason);
+    };
+    const refs = {
+        setPositionReference: (value) => {
+            positionReference = value;
+        },
+    };
+    const elements = $derived({
+        reference: positionReference || elementsProp.reference || null,
+        floating: elementsProp.floating || null,
+        domReference: elementsProp.reference,
+    });
+    return {
+        get dataRef() {
+            return dataRef;
+        },
+        get open() {
+            return open;
+        },
+        onOpenChange,
+        get elements() {
+            return elements;
+        },
+        events,
+        get floatingId() {
+            return floatingId;
+        },
+        refs,
+    };
+}

package/dist/utils/floating-ui/svelte/hooks/useId.svelte.d.ts

@@ -0,0 +1,9 @@
+declare function useFloatingId(): string;
+/**
+ * Uses React 18's built-in `useId()` when available, or falls back to a
+ * slightly less performant (requiring a double render) implementation for
+ * earlier React versions.
+ * @see https://floating-ui.com/docs/react-utils#useid
+ */
+export declare const useId: typeof useFloatingId;
+export {};

package/dist/utils/floating-ui/svelte/hooks/useId.svelte.js

@@ -0,0 +1,28 @@
+let serverHandoffComplete = false;
+let count = 0;
+const genId = () => 
+// Ensure the id is unique with multiple independent versions of Floating UI
+// on <React 18
+`floating-ui-${Math.random().toString(36).slice(2, 6)}${count++}`;
+function useFloatingId() {
+    /*let id = $state(serverHandoffComplete ? genId() : undefined)
+  
+    $effect(() => {
+      if (id == null) {
+        id = genId()
+      }
+    })
+  
+    $effect(() => {
+      serverHandoffComplete = true
+    })*/
+    return genId();
+}
+//const useReactId = SafeReact.useId as () => string
+/**
+ * Uses React 18's built-in `useId()` when available, or falls back to a
+ * slightly less performant (requiring a double render) implementation for
+ * earlier React versions.
+ * @see https://floating-ui.com/docs/react-utils#useid
+ */
+export const useId = /*useReactId ||*/ useFloatingId;