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

package/dist/transition/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Transition, type TransitionRootProps } from "./Transition.svelte";
+export { default as TransitionChild, type TransitionChildProps } from "./TransitionChild.svelte";

package/dist/transition/index.js

@@ -0,0 +1,2 @@
+export { default as Transition } from "./Transition.svelte";
+export { default as TransitionChild } from "./TransitionChild.svelte";

package/dist/utils/ElementOrComponent.svelte

@@ -0,0 +1,26 @@
+<script lang="ts" generics="TFeature extends RenderFeatures, TTag extends ElementType, TSlot, TValue">import { mergePropsAdvanced, RenderFeatures, RenderStrategy } from "./render.js";
+import Generic from "./Generic.svelte";
+let {
+  ourProps,
+  theirProps,
+  slots,
+  slot = slots,
+  defaultTag,
+  features,
+  visible = true,
+  name,
+  ref = $bindable(),
+  value = $bindable(),
+  checked = $bindable()
+} = $props();
+const featureFlags = $derived(features ?? RenderFeatures.None);
+const { static: isStatic = false, unmount = true, ...rest } = $derived(mergePropsAdvanced(theirProps, ourProps ?? {}));
+const render = $derived(
+  visible || featureFlags & RenderFeatures.Static && isStatic || featureFlags & RenderFeatures.RenderStrategy && !unmount
+);
+const hiddenProps = $derived(
+  !visible && !(featureFlags & RenderFeatures.Static) && featureFlags & RenderFeatures.RenderStrategy && !unmount ? { hidden: true, style: "display: none;" } : {}
+);
+</script>
+
+{#if render}<Generic {...rest} {...hiddenProps} {slot} tag={defaultTag} {name} bind:ref bind:value bind:checked />{/if}

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

@@ -0,0 +1,43 @@
+<script lang="ts" module>import { useId } from "../hooks/use-id.js";
+import { getContext, setContext } from "svelte";
+function createCollection() {
+  return {
+    /** @type {Map<string, Map<string, number>>} */
+    groups: /* @__PURE__ */ new Map(),
+    get(group, key) {
+      let list = this.groups.get(group);
+      if (!list) {
+        list = /* @__PURE__ */ new Map();
+        this.groups.set(group, list);
+      }
+      let renders = list.get(key) ?? 0;
+      list.set(key, renders + 1);
+      let index = Array.from(list.keys()).indexOf(key);
+      function release() {
+        let renders2 = list.get(key);
+        if (renders2 > 1) {
+          list.set(key, renders2 - 1);
+        } else {
+          list.delete(key);
+        }
+      }
+      return [index, release];
+    }
+  };
+}
+export function useStableCollectionIndex(group) {
+  let collection = getContext("StableCollection");
+  if (!collection) throw new Error("You must wrap your component in a <StableCollection>");
+  let key = useId();
+  let [idx, cleanupIdx] = collection.get(group, key);
+  $effect(() => cleanupIdx);
+  return idx;
+}
+</script>
+
+<script lang="ts">const collection = createCollection();
+setContext("StableCollection", collection);
+let { children } = $props();
+</script>
+
+{#if children}{@render children()}{/if}

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

@@ -0,0 +1,22 @@
+import { type Snippet } from "svelte";
+export declare function useStableCollectionIndex(group: string): number;
+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 StableCollection: $$__sveltets_2_IsomorphicComponent<{
+    children: Snippet;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, "">;
+type StableCollection = InstanceType<typeof StableCollection>;
+export default StableCollection;

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/calculate-active-index.d.ts

@@ -0,0 +1,25 @@
+export declare enum Focus {
+    /** Focus the first non-disabled item. */
+    First = 0,
+    /** Focus the previous non-disabled item. */
+    Previous = 1,
+    /** Focus the next non-disabled item. */
+    Next = 2,
+    /** Focus the last non-disabled item. */
+    Last = 3,
+    /** Focus a specific item based on the `id` of the item. */
+    Specific = 4,
+    /** Focus no items at all. */
+    Nothing = 5
+}
+export declare function calculateActiveIndex<TItem>(action: {
+    focus: Focus.Specific;
+    id: string;
+} | {
+    focus: Exclude<Focus, Focus.Specific>;
+}, resolvers: {
+    resolveItems(): TItem[];
+    resolveActiveIndex(): number | null;
+    resolveId(item: TItem, index: number, items: TItem[]): string;
+    resolveDisabled(item: TItem, index: number, items: TItem[]): boolean;
+}): number | null;

package/dist/utils/calculate-active-index.js

@@ -0,0 +1,74 @@
+function assertNever(x) {
+    throw new Error("Unexpected object: " + x);
+}
+export var Focus;
+(function (Focus) {
+    /** Focus the first non-disabled item. */
+    Focus[Focus["First"] = 0] = "First";
+    /** Focus the previous non-disabled item. */
+    Focus[Focus["Previous"] = 1] = "Previous";
+    /** Focus the next non-disabled item. */
+    Focus[Focus["Next"] = 2] = "Next";
+    /** Focus the last non-disabled item. */
+    Focus[Focus["Last"] = 3] = "Last";
+    /** Focus a specific item based on the `id` of the item. */
+    Focus[Focus["Specific"] = 4] = "Specific";
+    /** Focus no items at all. */
+    Focus[Focus["Nothing"] = 5] = "Nothing";
+})(Focus || (Focus = {}));
+export function calculateActiveIndex(action, resolvers) {
+    const items = resolvers.resolveItems();
+    if (items.length <= 0)
+        return null;
+    const currentActiveIndex = resolvers.resolveActiveIndex();
+    let activeIndex = currentActiveIndex ?? -1;
+    switch (action.focus) {
+        case Focus.First: {
+            for (let i = 0; i < items.length; ++i) {
+                if (!resolvers.resolveDisabled(items[i], i, items)) {
+                    return i;
+                }
+            }
+            return currentActiveIndex;
+        }
+        case Focus.Previous: {
+            // If nothing is active, focus the last relevant item
+            if (activeIndex === -1)
+                activeIndex = items.length;
+            for (let i = activeIndex - 1; i >= 0; --i) {
+                if (!resolvers.resolveDisabled(items[i], i, items)) {
+                    return i;
+                }
+            }
+            return currentActiveIndex;
+        }
+        case Focus.Next: {
+            for (let i = activeIndex + 1; i < items.length; ++i) {
+                if (!resolvers.resolveDisabled(items[i], i, items)) {
+                    return i;
+                }
+            }
+            return currentActiveIndex;
+        }
+        case Focus.Last: {
+            for (let i = items.length - 1; i >= 0; --i) {
+                if (!resolvers.resolveDisabled(items[i], i, items)) {
+                    return i;
+                }
+            }
+            return currentActiveIndex;
+        }
+        case Focus.Specific: {
+            for (let i = 0; i < items.length; ++i) {
+                if (resolvers.resolveId(items[i], i, items) === action.id) {
+                    return i;
+                }
+            }
+            return currentActiveIndex;
+        }
+        case Focus.Nothing:
+            return null;
+        default:
+            assertNever(action);
+    }
+}

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/default-map.d.ts

@@ -0,0 +1,5 @@
+export declare class DefaultMap<T = string, V = any> extends Map<T, V> {
+    private factory;
+    constructor(factory: (key: T) => V);
+    get(key: T): V;
+}

package/dist/utils/default-map.js

@@ -0,0 +1,15 @@
+export class DefaultMap extends Map {
+    factory;
+    constructor(factory) {
+        super();
+        this.factory = factory;
+    }
+    get(key) {
+        let value = super.get(key);
+        if (value === undefined) {
+            value = this.factory(key);
+            this.set(key, value);
+        }
+        return value;
+    }
+}

package/dist/utils/disposables.d.ts

@@ -1,4 +1,15 @@
-export type Disposables = ReturnType<typeof disposables>;
+import { microTask } from "./microTask.js";
+export type Disposables = {
+    addEventListener: <TEventName extends keyof WindowEventMap>(element: HTMLElement | Window | Document, name: TEventName, listener: (event: WindowEventMap[TEventName]) => any, options?: boolean | AddEventListenerOptions) => () => void;
+    requestAnimationFrame: (...args: Parameters<typeof requestAnimationFrame>) => () => void;
+    nextFrame: (...args: Parameters<typeof requestAnimationFrame>) => () => void;
+    setTimeout: (...args: Parameters<typeof setTimeout>) => () => void;
+    microTask: (...args: Parameters<typeof microTask>) => () => void;
+    style: (node: HTMLElement, property: string, value: string) => () => void;
+    group: (cb: (d: Disposables) => void) => () => void;
+    add: (cb: () => void) => () => void;
+    dispose: () => void;
+};
 /**
  * Disposables are a way to manage event handlers and functions like
  * `setTimeout` and `requestAnimationFrame` that need to be cleaned up when they
@@ -11,14 +22,5 @@ export type Disposables = ReturnType<typeof disposables>;
  * `dispose` function on the collection itself that can be used to clean up all
  * pending disposables in that collection.
  */
-export declare function disposables(): {
-    addEventListener<TEventName extends keyof WindowEventMap>(element: HTMLElement | Window | Document, name: TEventName, listener: (event: WindowEventMap[TEventName]) => any, options?: boolean | AddEventListenerOptions): () => void;
-    requestAnimationFrame(callback: FrameRequestCallback): () => void;
-    nextFrame(callback: FrameRequestCallback): () => void;
-    setTimeout(callback: (args: void) => void, ms?: number | undefined): () => void;
-    microTask(cb: () => void): () => void;
-    style(node: HTMLElement, property: string, value: string): () => void;
-    group(cb: (d: typeof this) => void): () => void;
-    add(cb: () => void): () => void;
-    dispose(): void;
-};
+export declare function disposables(): Disposables;
+export { disposables as useDisposables };

package/dist/utils/disposables.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { microTask } from "./microTask.js";
 /**
  * Disposables are a way to manage event handlers and functions like
@@ -12,14 +13,15 @@ import { microTask } from "./microTask.js";
  * pending disposables in that collection.
  */
 export function disposables() {
-    let _disposables = [];
-    let api = {
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    const _disposables = [];
+    const api = {
         addEventListener(element, name, listener, options) {
             element.addEventListener(name, listener, options);
             return api.add(() => element.removeEventListener(name, listener, options));
         },
         requestAnimationFrame(...args) {
-            let raf = requestAnimationFrame(...args);
+            const raf = requestAnimationFrame(...args);
             return api.add(() => cancelAnimationFrame(raf));
         },
         nextFrame(...args) {
@@ -28,11 +30,11 @@ export function disposables() {
             });
         },
         setTimeout(...args) {
-            let timer = setTimeout(...args);
+            const timer = setTimeout(...args);
             return api.add(() => clearTimeout(timer));
         },
         microTask(...args) {
-            let task = { current: true };
+            const task = { current: true };
             microTask(() => {
                 if (task.current) {
                     args[0]();
@@ -43,14 +45,14 @@ export function disposables() {
             });
         },
         style(node, property, value) {
-            let previous = node.style.getPropertyValue(property);
+            const previous = node.style.getPropertyValue(property);
             Object.assign(node.style, { [property]: value });
             return this.add(() => {
                 Object.assign(node.style, { [property]: previous });
             });
         },
         group(cb) {
-            let d = disposables();
+            const d = disposables();
             cb(d);
             return this.add(() => d.dispose());
         },
@@ -60,19 +62,20 @@ export function disposables() {
                 _disposables.push(cb);
             }
             return () => {
-                let idx = _disposables.indexOf(cb);
+                const idx = _disposables.indexOf(cb);
                 if (idx >= 0) {
-                    for (let dispose of _disposables.splice(idx, 1)) {
+                    for (const dispose of _disposables.splice(idx, 1)) {
                         dispose();
                     }
                 }
             };
         },
         dispose() {
-            for (let dispose of _disposables.splice(0)) {
+            for (const dispose of _disposables.splice(0)) {
                 dispose();
             }
         },
     };
     return api;
 }
+export { disposables as useDisposables };

package/dist/utils/dom.d.ts

@@ -1,3 +1 @@
-/// <reference types="node" />
-export declare const getOwnerDocument: (el: Element | null | undefined) => Document;
 export declare const getOwnerWindow: (el: (Window & typeof global) | Element | null | undefined) => Window & typeof global;

package/dist/utils/dom.js

@@ -1,10 +1,8 @@
-export const getOwnerDocument = (el) => {
-    return el?.ownerDocument ?? document;
-};
+import { getOwnerDocument } from "./owner.js";
 export const getOwnerWindow = (el) => {
     if (el && "window" in el && el.window === el) {
         return el;
     }
     const doc = getOwnerDocument(el);
-    return doc.defaultView || window;
+    return doc?.defaultView || window;
 };

package/dist/utils/env.d.ts

@@ -0,0 +1,17 @@
+type RenderEnv = "client" | "server";
+type HandoffState = "pending" | "complete";
+declare class Env {
+    current: RenderEnv;
+    handoffState: HandoffState;
+    currentId: number;
+    set(env: RenderEnv): void;
+    reset(): void;
+    nextId(): number;
+    get isServer(): boolean;
+    get isClient(): boolean;
+    private detect;
+    handoff(): void;
+    get isHandoffComplete(): boolean;
+}
+export declare let env: Env;
+export {};

package/dist/utils/env.js

@@ -0,0 +1,39 @@
+class Env {
+    current = this.detect();
+    handoffState = "pending";
+    currentId = 0;
+    set(env) {
+        if (this.current === env)
+            return;
+        this.handoffState = "pending";
+        this.currentId = 0;
+        this.current = env;
+    }
+    reset() {
+        this.set(this.detect());
+    }
+    nextId() {
+        return ++this.currentId;
+    }
+    get isServer() {
+        return this.current === "server";
+    }
+    get isClient() {
+        return this.current === "client";
+    }
+    detect() {
+        if (typeof window === "undefined" || typeof document === "undefined") {
+            return "server";
+        }
+        return "client";
+    }
+    handoff() {
+        if (this.handoffState === "pending") {
+            this.handoffState = "complete";
+        }
+    }
+    get isHandoffComplete() {
+        return this.handoffState === "complete";
+    }
+}
+export let env = new Env();