@pzerelles/headlessui-svelte 2.0.0-next.1 → 2.1.2-next.10

package/dist/internal/ForcePortalRoot.svelte

@@ -0,0 +1,6 @@
+<script lang="ts">import { createPortalRoot } from "./portal-force-root.svelte.js";
+let { force, children } = $props();
+createPortalRoot({ force });
+</script>
+
+{#if children}{@render children()}{/if}

package/dist/internal/ForcePortalRoot.svelte.d.ts

@@ -0,0 +1,22 @@
+import type { Snippet } from "svelte";
+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 ForcePortalRoot: $$__sveltets_2_IsomorphicComponent<{
+    force: boolean;
+    children: Snippet;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, "">;
+type ForcePortalRoot = InstanceType<typeof ForcePortalRoot>;
+export default ForcePortalRoot;

package/dist/internal/FormFields.svelte

@@ -14,10 +14,8 @@ let {
 let form = $state(null);
 const d = disposables();
 $effect(() => {
-  if (!onReset)
-    return;
-  if (!form)
-    return;
+  if (!onReset) return;
+  if (!form) return;
   return d.addEventListener(form, "reset", onReset);
 });
 </script>

package/dist/internal/FormFields.svelte.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="svelte" />
 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;
@@ -6,17 +5,20 @@ 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 FormFields: $$__sveltets_2_IsomorphicComponent<{
     data: Record<string, any>;
-    overrides?: Record<string, any> | undefined;
-    form?: string | undefined;
-    disabled?: boolean | undefined;
-    onReset?: ((e: Event) => void) | undefined;
+    overrides?: Record<string, any>;
+    form?: string;
+    disabled?: boolean;
+    onReset?: (e: Event) => void;
 }, {
     [evt: string]: CustomEvent<any>;
-}, {}, Record<string, any>, "">;
+}, {}, {}, "">;
 type FormFields = InstanceType<typeof FormFields>;
 export default FormFields;

package/dist/internal/FormResolver.svelte

@@ -1,25 +1,20 @@
-<script lang="ts">import Hidden, { HiddenFeatures } from "./Hidden.svelte";
+<script lang="ts">import { onMount } from "svelte";
+import Hidden, { HiddenFeatures } from "./Hidden.svelte";
 let { setForm, formId } = $props();
 $effect(() => {
   if (formId) {
-    let resolvedForm = document.getElementById(formId);
-    if (resolvedForm)
-      setForm(resolvedForm);
+    const resolvedForm = document.getElementById(formId);
+    if (resolvedForm) setForm(resolvedForm);
   }
 });
+let element = $state();
+onMount(() => {
+  if (!element) return;
+  const resolvedForm = element.closest("form");
+  if (resolvedForm) setForm(resolvedForm);
+});
 </script>
 
 {#if !formId}
-  <Hidden
-    features={HiddenFeatures.Hidden}
-    as="input"
-    type="hidden"
-    hidden
-    readonly
-    ref={(el) => {
-      if (!el) return
-      let resolvedForm = el.closest("form")
-      if (resolvedForm) setForm(resolvedForm)
-    }}
-  />
+  <Hidden features={HiddenFeatures.Hidden} as="input" type="hidden" hidden readonly bind:ref={element} />
 {/if}

package/dist/internal/FormResolver.svelte.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="svelte" />
 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;
@@ -6,14 +5,17 @@ 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 FormResolver: $$__sveltets_2_IsomorphicComponent<{
     setForm: (form: HTMLFormElement) => void;
-    formId?: string | undefined;
+    formId?: string;
 }, {
     [evt: string]: CustomEvent<any>;
-}, {}, Record<string, any>, "">;
+}, {}, {}, "">;
 type FormResolver = InstanceType<typeof FormResolver>;
 export default FormResolver;

package/dist/internal/Hidden.svelte

@@ -1,18 +1,10 @@
-<script lang="ts" context="module">export var HiddenFeatures = /* @__PURE__ */ ((HiddenFeatures2) => {
-  HiddenFeatures2[HiddenFeatures2["None"] = 1] = "None";
-  HiddenFeatures2[HiddenFeatures2["Focusable"] = 2] = "Focusable";
-  HiddenFeatures2[HiddenFeatures2["Hidden"] = 4] = "Hidden";
-  return HiddenFeatures2;
-})(HiddenFeatures || {});
+<script lang="ts" module>import ElementOrComponent from "../utils/ElementOrComponent.svelte";
+import { HiddenFeatures } from "./HiddenFeatures.js";
+export * from "./HiddenFeatures.js";
+const DEFAULT_VISUALLY_HIDDEN_TAG = "span";
 </script>
 
-<script lang="ts">import { onMount } from "svelte";
-const DEFAULT_VISUALLY_HIDDEN_TAG = "div";
-let { as = "div", features = HiddenFeatures.None, ref: applyRef, ...theirProps } = $props();
-let ref = $state();
-onMount(() => {
-  applyRef?.(ref);
-});
+<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_VISUALLY_HIDDEN_TAG">let { ref = $bindable(), features = HiddenFeatures.None, ...theirProps } = $props();
 let ourProps = {
   "aria-hidden": (features & HiddenFeatures.Focusable) === HiddenFeatures.Focusable ? true : theirProps["aria-hidden"] ?? void 0,
   hidden: (features & HiddenFeatures.Hidden) === HiddenFeatures.Hidden ? true : void 0,
@@ -33,4 +25,4 @@ let ourProps = {
 };
 </script>
 
-<svelte:element this={as} {...theirProps} {...ourProps} bind:this={ref} />
+<ElementOrComponent {ourProps} {theirProps} defaultTag={DEFAULT_VISUALLY_HIDDEN_TAG} name="Hidden" bind:ref />

package/dist/internal/Hidden.svelte.d.ts

@@ -1,26 +1,39 @@
-/// <reference types="svelte" />
-export declare enum HiddenFeatures {
-    None = 1,
-    Focusable = 2,
-    Hidden = 4
+import type { ElementType, Props } from "../utils/types.js";
+import { HiddenFeatures } from "./HiddenFeatures.js";
+export * from "./HiddenFeatures.js";
+declare const DEFAULT_VISUALLY_HIDDEN_TAG: "span";
+type HiddenRenderPropArg = {};
+type HiddenPropsWeControl = never;
+export type HiddenProps<TTag extends ElementType = typeof DEFAULT_VISUALLY_HIDDEN_TAG> = Props<TTag, HiddenRenderPropArg, HiddenPropsWeControl, {
+    features?: HiddenFeatures;
+}>;
+declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_VISUALLY_HIDDEN_TAG> {
+    props(): {
+        as?: TTag | undefined;
+    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, ("as" | "children" | "refName" | "class") | "features"> extends infer T extends keyof import("../utils/types.js").PropsOf<TTag> ? { [P in T]: import("../utils/types.js").PropsOf<TTag>[P]; } : never) & {
+        children?: import("../utils/types.js").Children<HiddenRenderPropArg> | undefined;
+        ref?: HTMLElement;
+    } & (true extends (import("../utils/types.js").PropsOf<TTag> extends infer T_1 ? T_1 extends import("../utils/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("../utils/types.js").PropsOf<TTag>["class"] | ((bag: HiddenRenderPropArg) => string) | undefined;
+    } : {}) & {
+        features?: HiddenFeatures;
+    };
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "ref";
+    exports(): {};
 }
-import type { HTMLInputAttributes } from "svelte/elements";
-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;
-    z_$$bindings?: Bindings;
+interface $$IsomorphicComponent {
+    new <TTag extends ElementType = typeof DEFAULT_VISUALLY_HIDDEN_TAG>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TTag>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TTag>['props']>, ReturnType<__sveltets_Render<TTag>['events']>, ReturnType<__sveltets_Render<TTag>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TTag>['bindings']>;
+    } & ReturnType<__sveltets_Render<TTag>['exports']>;
+    <TTag extends ElementType = typeof DEFAULT_VISUALLY_HIDDEN_TAG>(internal: unknown, props: ReturnType<__sveltets_Render<TTag>['props']> & {
+        $$events?: ReturnType<__sveltets_Render<TTag>['events']>;
+    }): ReturnType<__sveltets_Render<TTag>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
-declare const Hidden: $$__sveltets_2_IsomorphicComponent<Omit<HTMLInputAttributes, "style"> & {
-    as?: string | undefined;
-    features?: HiddenFeatures | undefined;
-    ref?: ((el: HTMLElement) => void) | undefined;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, Record<string, any>, "">;
-type Hidden = InstanceType<typeof Hidden>;
+declare const Hidden: $$IsomorphicComponent;
+type Hidden<TTag extends ElementType = typeof DEFAULT_VISUALLY_HIDDEN_TAG> = InstanceType<typeof Hidden<TTag>>;
 export default Hidden;

package/dist/internal/HiddenFeatures.d.ts

@@ -0,0 +1,5 @@
+export declare enum HiddenFeatures {
+    None = 1,
+    Focusable = 2,
+    Hidden = 4
+}

package/dist/internal/HiddenFeatures.js

@@ -0,0 +1,9 @@
+export var HiddenFeatures;
+(function (HiddenFeatures) {
+    // The default, no features.
+    HiddenFeatures[HiddenFeatures["None"] = 1] = "None";
+    // Whether the element should be focusable or not.
+    HiddenFeatures[HiddenFeatures["Focusable"] = 2] = "Focusable";
+    // Whether it should be completely hidden, even to assistive technologies.
+    HiddenFeatures[HiddenFeatures["Hidden"] = 4] = "Hidden";
+})(HiddenFeatures || (HiddenFeatures = {}));

package/dist/internal/HoistFormFields.svelte.d.ts

@@ -6,13 +6,16 @@ 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 HoistFormFields: $$__sveltets_2_IsomorphicComponent<{
     children: Snippet;
 }, {
     [evt: string]: CustomEvent<any>;
-}, {}, Record<string, any>, "">;
+}, {}, {}, "">;
 type HoistFormFields = InstanceType<typeof HoistFormFields>;
 export default HoistFormFields;

package/dist/internal/MainTreeProvider.svelte

@@ -0,0 +1,45 @@
+<script lang="ts" module>import { getContext, onMount } from "svelte";
+export function useMainTreeNode(options = {}) {
+  const { fallbackMainTreeNode = null } = $derived(options);
+  return getContext("MainTreeContext") ?? {
+    get node() {
+      return fallbackMainTreeNode;
+    }
+  };
+}
+</script>
+
+<script lang="ts">import { setContext } from "svelte";
+import Hidden, { HiddenFeatures } from "./Hidden.svelte";
+import { getOwnerDocument } from "../utils/owner.js";
+let { node, children } = $props();
+let mainTreeNode = $state(null);
+const resolvedMainTreeNode = useMainTreeNode({
+  get fallbackMainTreeNode() {
+    return node ?? mainTreeNode;
+  }
+});
+setContext("MainTreeContext", {
+  get node() {
+    return resolvedMainTreeNode.node;
+  }
+});
+let el = $state();
+onMount(() => {
+  if (!el) return;
+  for (let container of getOwnerDocument(el)?.querySelectorAll("html > *, body > *") ?? []) {
+    if (container === document.body) continue;
+    if (container === document.head) continue;
+    if (!(container instanceof HTMLElement)) continue;
+    if (container?.contains(el)) {
+      mainTreeNode = container;
+      break;
+    }
+  }
+});
+</script>
+
+{#if children}{@render children()}{/if}
+{#if resolvedMainTreeNode === null}
+  <Hidden features={HiddenFeatures.Hidden} bind:ref={el} />
+{/if}

package/dist/internal/MainTreeProvider.svelte.d.ts

@@ -0,0 +1,31 @@
+type MainTreeContext = {
+    node: HTMLElement | null;
+};
+/**
+ * Get the main tree node from context or fallback to the optionally provided node.
+ */
+export declare function useMainTreeNode(options?: {
+    fallbackMainTreeNode?: HTMLElement | null;
+}): MainTreeContext;
+import { type Snippet } from "svelte";
+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 MainTreeProvider: $$__sveltets_2_IsomorphicComponent<{
+    children: Snippet;
+    node?: HTMLElement | null;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, "">;
+type MainTreeProvider = InstanceType<typeof MainTreeProvider>;
+export default MainTreeProvider;

package/dist/internal/Portal.svelte.d.ts

@@ -6,7 +6,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 Portal: $$__sveltets_2_IsomorphicComponent<{
@@ -14,6 +17,6 @@ declare const Portal: $$__sveltets_2_IsomorphicComponent<{
     children: Snippet;
 }, {
     [evt: string]: CustomEvent<any>;
-}, {}, Record<string, any>, "">;
+}, {}, {}, "">;
 type Portal = InstanceType<typeof Portal>;
 export default Portal;

package/dist/internal/close-provider.d.ts

@@ -0,0 +1,7 @@
+export type CloseContext = {
+    close: () => void;
+};
+export declare function useClose(): CloseContext;
+export declare function createCloseContext(options: {
+    readonly close: () => void;
+}): void;

package/dist/internal/close-provider.js

@@ -0,0 +1,7 @@
+import { getContext, setContext } from "svelte";
+export function useClose() {
+    return getContext("CloseContext");
+}
+export function createCloseContext(options) {
+    setContext("CloseContext", options);
+}

package/dist/internal/floating.svelte.d.ts

@@ -0,0 +1,62 @@
+import type { MutableRefObject } from "../utils/ref.svelte.js";
+type Align = "start" | "end";
+type Placement = "top" | "right" | "bottom" | "left";
+type BaseAnchorProps = {
+    /**
+     * The `gap` is the space between the trigger and the panel.
+     */
+    gap: number | string;
+    /**
+     * The `offset` is the amount the panel should be nudged from its original position.
+     */
+    offset: number | string;
+    /**
+     * The `padding` is the minimum space between the panel and the viewport.
+     */
+    padding: number | string;
+};
+export type AnchorProps = false | (`${Placement}` | `${Placement} ${Align}`) | Partial<BaseAnchorProps & {
+    /**
+     * The `to` value defines which side of the trigger the panel should be placed on and its
+     * alignment.
+     */
+    to: `${Placement}` | `${Placement} ${Align}`;
+}>;
+export type AnchorPropsWithSelection = false | (`${Placement | "selection"}` | `${Placement | "selection"} ${Align}`) | Partial<BaseAnchorProps & {
+    /**
+     * The `to` value defines which side of the trigger the panel should be placed on and its
+     * alignment.
+     */
+    to: `${Placement | "selection"}` | `${Placement | "selection"} ${Align}`;
+}>;
+export type InternalFloatingPanelProps = Partial<{
+    inner: {
+        listRef: MutableRefObject<(HTMLElement | null)[]>;
+        index: () => number | null;
+    };
+}>;
+type FloatingContext = {
+    styles?: string;
+    setReference: (reference: HTMLElement | null | undefined) => void;
+    setFloating: (floating: HTMLElement | null | undefined) => void;
+    getReferenceProps: () => Record<string, any>;
+    getFloatingProps: () => Record<string, any>;
+    slot: Partial<{
+        anchor: `${Placement | "selection"}` | `${Placement | "selection"} ${Align}`;
+    }>;
+};
+export declare function useResolvedAnchor<T extends AnchorProps | AnchorPropsWithSelection>(anchor?: T): Exclude<T, boolean | string> | null;
+export declare function useFloating(): FloatingContext;
+export declare function useFloatingPanelProps(): () => Record<string, any> & {
+    "data-anchor": Placement | "top end" | "top start" | "right end" | "right start" | "bottom end" | "bottom start" | "left end" | "left start" | "selection" | "selection end" | "selection start" | undefined;
+};
+export declare function useFloatingPanel(options: {
+    placement: (AnchorPropsWithSelection & InternalFloatingPanelProps) | null;
+}): {
+    readonly setFloating: (floating: HTMLElement | null | undefined) => void;
+    readonly style: string | undefined;
+};
+export declare const createFloatingContext: ({ enabled }?: {
+    enabled?: boolean;
+}) => FloatingContext;
+export {};