@pzerelles/headlessui-svelte 2.0.0-next.1

package/README.md

@@ -0,0 +1,58 @@
+# create-svelte
+
+Everything you need to build a Svelte library, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/main/packages/create-svelte).
+
+Read more about creating a library [in the docs](https://kit.svelte.dev/docs/packaging).
+
+## Creating a project
+
+If you're seeing this, you've probably already done this step. Congrats!
+
+```bash
+# create a new project in the current directory
+npm create svelte@latest
+
+# create a new project in my-app
+npm create svelte@latest my-app
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```bash
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.
+
+## Building
+
+To build your library:
+
+```bash
+npm run package
+```
+
+To create a production version of your showcase app:
+
+```bash
+npm run build
+```
+
+You can preview the production build with `npm run preview`.
+
+> To deploy your app, you may need to install an [adapter](https://kit.svelte.dev/docs/adapters) for your target environment.
+
+## Publishing
+
+Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).
+
+To publish your library to [npm](https://www.npmjs.com):
+
+```bash
+npm publish
+```

package/dist/actions/activePress.svelte.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="svelte" />
+import type { Action } from "svelte/action";
+export declare const createActivePress: ({ disabled }: {
+    disabled?: boolean;
+}) => {
+    activePressAction: Action<HTMLElement, undefined, Record<never, any>>;
+    readonly pressed: boolean;
+};

package/dist/actions/activePress.svelte.js

@@ -0,0 +1,84 @@
+import { disposables } from "../utils/disposables.js";
+import { getOwnerDocument } from "../utils/dom.js";
+function pointerRectFromPointerEvent(event) {
+    // Center of the pointer geometry
+    let offsetX = event.width / 2;
+    let offsetY = event.height / 2;
+    return {
+        top: event.clientY - offsetY,
+        right: event.clientX + offsetX,
+        bottom: event.clientY + offsetY,
+        left: event.clientX - offsetX,
+    };
+}
+function areRectsOverlapping(a, b) {
+    if (!a || !b) {
+        return false;
+    }
+    if (a.right < b.left || a.left > b.right) {
+        return false;
+    }
+    if (a.bottom < b.top || a.top > b.bottom) {
+        return false;
+    }
+    return true;
+}
+export const createActivePress = ({ disabled }) => {
+    let currentTarget = $state(null);
+    let pressed = $state(false);
+    const activePressAction = (node) => {
+        const d = disposables();
+        const reset = () => {
+            currentTarget = null;
+            pressed = false;
+            d.dispose();
+        };
+        const handlePointerDown = (event) => {
+            d.dispose(); // Cancel any scheduled tasks
+            if (currentTarget !== null)
+                return;
+            // Keep track of the current element
+            currentTarget = event.currentTarget;
+            // We are definitely pressing the element now
+            pressed = true;
+            // Setup global handlers to catch events on elements that are not the current element
+            {
+                let owner = getOwnerDocument(event.currentTarget);
+                // `pointerup` on any element means that we are no longer pressing the current element
+                d.addEventListener(owner, "pointerup", reset, false);
+                // `pointerleave` isn't called consistently (if at all) on iOS Safari, so we use `pointermove` instead
+                // to determine if we are still "pressing". We also compare the pointer position to the target element
+                // so that we can tell if the pointer is still over the element or not.
+                d.addEventListener(owner, "pointermove", (event) => {
+                    if (currentTarget) {
+                        let pointerRect = pointerRectFromPointerEvent(event);
+                        pressed = areRectsOverlapping(pointerRect, currentTarget.getBoundingClientRect());
+                    }
+                }, false);
+                // Whenever the browser decides to fire a `pointercancel` event, we should abort
+                d.addEventListener(owner, "pointercancel", reset, false);
+            }
+        };
+        if (!disabled) {
+            node.addEventListener("pointerdown", handlePointerDown);
+            node.addEventListener("pointerup", reset);
+            node.addEventListener("click", reset);
+        }
+        return {
+            destroy: () => {
+                if (!disabled) {
+                    node.removeEventListener("pointerdown", handlePointerDown);
+                    node.removeEventListener("pointerup", reset);
+                    node.removeEventListener("click", reset);
+                }
+                d.dispose();
+            },
+        };
+    };
+    return {
+        activePressAction,
+        get pressed() {
+            return pressed;
+        },
+    };
+};

package/dist/actions/focusRing.svelte.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="svelte" />
+import type { Action } from "svelte/action";
+export declare const createFocusRing: ({ autoFocus, within }?: {
+    autoFocus?: boolean;
+    within?: boolean;
+}) => {
+    focusRingAction: Action<HTMLElement, undefined, Record<never, any>>;
+    readonly focusVisible: boolean;
+};

package/dist/actions/focusRing.svelte.js

@@ -0,0 +1,34 @@
+import { isFocusVisible, useFocusVisibleListener } from "../utils/focusVisible.svelte.js";
+export const createFocusRing = ({ autoFocus = false, within } = {}) => {
+    let focused = $state(false);
+    let focusVisible = $state(autoFocus || isFocusVisible());
+    useFocusVisibleListener((isFocusVisible) => {
+        focusVisible = isFocusVisible;
+    });
+    const focusRingAction = (node) => {
+        const handleFocus = (e) => {
+            focused = true;
+        };
+        const handleBlur = (e) => {
+            focused = false;
+        };
+        if (!within) {
+            node.addEventListener("focus", handleFocus);
+            node.addEventListener("blur", handleBlur);
+        }
+        return {
+            destroy: () => {
+                if (!within) {
+                    node.removeEventListener("focus", handleFocus);
+                    node.removeEventListener("blur", handleBlur);
+                }
+            },
+        };
+    };
+    return {
+        focusRingAction,
+        get focusVisible() {
+            return focusVisible && focused;
+        },
+    };
+};

package/dist/checkbox/Checkbox.svelte

@@ -0,0 +1,114 @@
+<script lang="ts" context="module">const DEFAULT_CHECKBOX_TAG = "div";
+</script>
+
+<script lang="ts" generics="TTag extends keyof SvelteHTMLElements, TType">import { tick } from "svelte";
+import { createHover } from "svelte-interactions";
+import { attemptSubmit } from "../utils/form.js";
+import { getIdContext, htmlid } from "../utils/id.js";
+import { createActivePress } from "../actions/activePress.svelte.js";
+import { createFocusRing } from "../actions/focusRing.svelte.js";
+import FormFields from "../internal/FormFields.svelte";
+import { getLabelContext } from "../label/Label.svelte";
+import { getDisabledContext } from "../utils/disabled.js";
+import { stateFromSlot } from "../utils/state.js";
+const internalId = htmlid();
+const providedId = getIdContext();
+const providedDisabled = getDisabledContext();
+let {
+  id = providedId || `headlessui-checkbox-${internalId}`,
+  as,
+  value,
+  disabled: ownDisabled = false,
+  indeterminate = false,
+  defaultChecked,
+  checked = $bindable(defaultChecked ?? false),
+  autoFocus,
+  form,
+  name,
+  onchange,
+  children,
+  ...theirProps
+} = $props();
+const disabled = $derived(providedDisabled?.disabled || ownDisabled);
+const { hoverAction: hover, isHovered } = $derived(createHover({ isDisabled: disabled }));
+const ap = $derived(createActivePress({ disabled }));
+const fr = createFocusRing({ autoFocus });
+const labelContext = getLabelContext();
+const labelledBy = $derived(labelContext?.labelledBy);
+let changing = $state(false);
+const toggle = () => {
+  changing = true;
+  checked = !checked;
+  onchange?.(checked);
+  tick().then(() => {
+    changing = false;
+  });
+};
+const handleClick = (event) => {
+  if (disabled)
+    return event.preventDefault();
+  event.preventDefault();
+  toggle();
+};
+const handleKeyUp = (event) => {
+  if (event.key === " ") {
+    event.preventDefault();
+    toggle();
+  } else if (event.key === "Enter") {
+    if (event.currentTarget)
+      attemptSubmit(event.currentTarget);
+  }
+};
+const handleKeyPress = (event) => event.preventDefault();
+const slot = $derived({
+  checked,
+  changing,
+  focus: fr.focusVisible,
+  active: ap.pressed,
+  hover: $isHovered,
+  autofocus: autoFocus ?? false,
+  disabled,
+  indeterminate
+});
+const states = $derived(
+  Object.entries(slot).filter(([, value2]) => value2).map(([key]) => key)
+);
+const ownProps = $derived({
+  id,
+  role: "checkbox",
+  "aria-checked": indeterminate ? "mixed" : checked ? true : false,
+  "aria-labelledby": labelledBy,
+  "aria-describedby": void 0,
+  "aria-disabled": disabled ? true : void 0,
+  tabindex: disabled ? void 0 : 0,
+  onkeyup: disabled ? void 0 : handleKeyUp,
+  onkeypress: disabled ? void 0 : handleKeyPress,
+  onclick: disabled ? void 0 : handleClick,
+  ...stateFromSlot(slot)
+});
+const reset = $derived(() => {
+  if (defaultChecked === void 0)
+    return;
+  return onchange?.(defaultChecked);
+});
+</script>
+
+{#if name}
+  <FormFields
+    {disabled}
+    data={{ [name]: value || "on" }}
+    overrides={{ type: "checkbox", checked }}
+    {form}
+    onReset={reset}
+  />
+{/if}
+<svelte:element
+  this={as ?? DEFAULT_CHECKBOX_TAG}
+  use:hover
+  use:ap.activePressAction
+  use:fr.focusRingAction
+  {...ownProps}
+  {...theirProps}
+>
+  {#if children}{@render children(slot)}{/if}
+</svelte:element>

package/dist/checkbox/Checkbox.svelte.d.ts

@@ -0,0 +1,48 @@
+import type { SvelteHTMLElements } from "svelte/elements";
+export type CheckboxProps<TType = string, TTag extends keyof SvelteHTMLElements = typeof DEFAULT_CHECKBOX_TAG> = SvelteHTMLElements[TTag] & {
+    as?: TTag;
+    value?: TType;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    autoFocus?: boolean;
+    form?: string;
+    name?: string;
+    onchange?: (checked: boolean) => void;
+    children?: Snippet<[
+        {
+            checked: boolean;
+            changing: boolean;
+            focus: boolean;
+            active: boolean;
+            hover: boolean;
+            autofocus: boolean;
+            disabled: boolean;
+            indeterminate: boolean;
+        }
+    ]>;
+};
+declare const DEFAULT_CHECKBOX_TAG: "div";
+import { type Snippet } from "svelte";
+declare class __sveltets_Render<TTag extends keyof SvelteHTMLElements, TType> {
+    props(): CheckboxProps<TType, TTag>;
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "checked";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TTag extends keyof SvelteHTMLElements, TType>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TTag, TType>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TTag, TType>['props']>, ReturnType<__sveltets_Render<TTag, TType>['events']>, ReturnType<__sveltets_Render<TTag, TType>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TTag, TType>['bindings']>;
+    } & ReturnType<__sveltets_Render<TTag, TType>['exports']>;
+    <TTag extends keyof SvelteHTMLElements, TType>(internal: unknown, props: ReturnType<__sveltets_Render<TTag, TType>['props']> & {
+        $$events?: ReturnType<__sveltets_Render<TTag, TType>['events']>;
+    }): ReturnType<__sveltets_Render<TTag, TType>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
+}
+declare const Checkbox: $$IsomorphicComponent;
+type Checkbox<TTag extends keyof SvelteHTMLElements, TType> = InstanceType<typeof Checkbox<TTag, TType>>;
+export default Checkbox;

package/dist/checkbox/index.d.ts

@@ -0,0 +1 @@
+export { default as Checkbox, type CheckboxProps } from "./Checkbox.svelte";

package/dist/checkbox/index.js

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

package/dist/description/Description.svelte

@@ -0,0 +1,53 @@
+<script lang="ts" context="module">import { getContext, setContext, untrack } from "svelte";
+const DEFAULT_DESCRIPTION_TAG = "p";
+export const createDescriptionContext = () => {
+  let describedBy = $state();
+  setContext("Description", {
+    get describedBy() {
+      return describedBy;
+    },
+    register(id) {
+      describedBy = untrack(() => describedBy === void 0 ? id : `${describedBy} ${id}`.trim());
+    },
+    unregister(id) {
+      describedBy = untrack(
+        () => describedBy?.split(" ").filter((value) => value !== id).join(" ")
+      );
+    }
+  });
+};
+export const getDescriptionContext = () => getContext("Description");
+const validateDescriptionContext = () => {
+  const context = getDescriptionContext();
+  if (context === void 0) {
+    const err = new Error("You used a <Description /> component, but it is not inside a relevant parent.");
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(err, validateDescriptionContext);
+    throw err;
+  }
+  return context;
+};
+</script>
+
+<script lang="ts" generics="TTag extends keyof SvelteHTMLElements">import { htmlid } from "../utils/id.js";
+import { stateFromSlot } from "../utils/state.js";
+import { getDisabledContext } from "../utils/disabled.js";
+const internalId = htmlid();
+const providedDisabled = getDisabledContext();
+let { as, id = `headlessui-description-${internalId}`, children, ...theirProps } = $props();
+const context = validateDescriptionContext();
+$effect(() => {
+  context.register(id);
+  const registeredId = id;
+  return () => {
+    context.unregister(registeredId);
+  };
+});
+const disabled = $derived(providedDisabled?.disabled || false);
+const slot = $derived({ disabled });
+const ourProps = $derived({ id, ...stateFromSlot(slot) });
+</script>
+
+<svelte:element this={as ?? DEFAULT_DESCRIPTION_TAG} {...ourProps} {...theirProps}>
+  {#if children}{@render children(slot)}{/if}
+</svelte:element>

package/dist/description/Description.svelte.d.ts

@@ -0,0 +1,39 @@
+import type { SvelteHTMLElements } from "svelte/elements";
+import { type Snippet } from "svelte";
+export type DescriptionProps<TTag extends keyof SvelteHTMLElements = typeof DEFAULT_DESCRIPTION_TAG> = SvelteHTMLElements[TTag] & {
+    as?: TTag;
+    children?: Snippet<[
+        {
+            disabled: boolean;
+        }
+    ]>;
+};
+declare const DEFAULT_DESCRIPTION_TAG: "p";
+export type DescriptionContext = {
+    describedBy?: string;
+    register: (id: string) => void;
+    unregister: (id: string) => void;
+};
+export declare const createDescriptionContext: () => void;
+export declare const getDescriptionContext: () => DescriptionContext;
+declare class __sveltets_Render<TTag extends keyof SvelteHTMLElements> {
+    props(): DescriptionProps<TTag>;
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TTag extends keyof SvelteHTMLElements>(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 keyof SvelteHTMLElements>(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 Description: $$IsomorphicComponent;
+type Description<TTag extends keyof SvelteHTMLElements> = InstanceType<typeof Description<TTag>>;
+export default Description;

package/dist/description/index.d.ts

@@ -0,0 +1 @@
+export { default as Description, type DescriptionProps } from "./Description.svelte";

package/dist/description/index.js

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

package/dist/field/Field.svelte

@@ -0,0 +1,33 @@
+<script lang="ts" context="module">const DEFAULT_FIELD_TAG = "div";
+</script>
+
+<script lang="ts" generics="TTag extends keyof SvelteHTMLElements">import { createDescriptionContext } from "../description/Description.svelte";
+import { createLabelContext } from "../label/Label.svelte";
+import { getDisabledContext } from "../utils/disabled.js";
+import { createIdContext } from "../utils/id.js";
+import { stateFromSlot } from "../utils/state.js";
+import { nanoid } from "nanoid";
+import { setContext } from "svelte";
+let { as, disabled: ownDisabled = false, children, ...theirProps } = $props();
+const inputId = `headlessui-control-${nanoid(8)}`;
+createIdContext(inputId);
+createLabelContext();
+createDescriptionContext();
+const providedDisabled = getDisabledContext();
+const disabled = $derived(providedDisabled?.disabled || ownDisabled);
+setContext("Disabled", {
+  get disabled() {
+    return disabled;
+  }
+});
+const slot = $derived({ disabled });
+const ourProps = $derived({
+  disabled: disabled || void 0,
+  "aria-disabled": disabled || void 0,
+  ...stateFromSlot(slot)
+});
+</script>
+
+<svelte:element this={as ?? DEFAULT_FIELD_TAG} {...ourProps} {...theirProps}>
+  {#if children}{@render children(slot)}{/if}
+</svelte:element>

package/dist/field/Field.svelte.d.ts

@@ -0,0 +1,33 @@
+import type { SvelteHTMLElements } from "svelte/elements";
+export type FieldProps<TTag extends keyof SvelteHTMLElements = typeof DEFAULT_FIELD_TAG> = SvelteHTMLElements[TTag] & {
+    as?: TTag;
+    disabled?: boolean;
+    children?: Snippet<[
+        {
+            disabled: boolean;
+        }
+    ]>;
+};
+declare const DEFAULT_FIELD_TAG: "div";
+import { type Snippet } from "svelte";
+declare class __sveltets_Render<TTag extends keyof SvelteHTMLElements> {
+    props(): FieldProps<TTag>;
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TTag extends keyof SvelteHTMLElements>(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 keyof SvelteHTMLElements>(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 Field: $$IsomorphicComponent;
+type Field<TTag extends keyof SvelteHTMLElements> = InstanceType<typeof Field<TTag>>;
+export default Field;

package/dist/field/index.d.ts

@@ -0,0 +1 @@
+export { default as Field, type FieldProps } from "./Field.svelte";

package/dist/field/index.js

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

package/dist/fieldset/Fieldset.svelte

@@ -0,0 +1,32 @@
+<script lang="ts" context="module">const DEFAULT_FIELDSET_TAG = "fieldset";
+</script>
+
+<script lang="ts" generics="TTag extends keyof SvelteHTMLElements">import { setContext } from "svelte";
+import { getDisabledContext } from "../utils/disabled.js";
+import { createLabelContext } from "../label/Label.svelte";
+let { as, disabled: ownDisabled = false, children, ...theirProps } = $props();
+const providedDisabled = getDisabledContext();
+const disabled = $derived(providedDisabled?.disabled || ownDisabled);
+setContext("Disabled", {
+  get disabled() {
+    return disabled;
+  }
+});
+const tag = $state(as ?? DEFAULT_FIELDSET_TAG);
+const labelContext = createLabelContext();
+const slot = $derived({ disabled });
+const ourProps = $derived(
+  tag === "fieldset" ? {
+    "aria-labelledby": labelContext.labelledBy,
+    disabled: disabled || void 0
+  } : {
+    role: "group",
+    "aria-labelledby": labelContext.labelledBy,
+    "aria-disabled": disabled || void 0
+  }
+);
+</script>
+
+<svelte:element this={tag} {...ourProps} {...theirProps}>
+  {#if children}{@render children(slot)}{/if}
+</svelte:element>

package/dist/fieldset/Fieldset.svelte.d.ts

@@ -0,0 +1,33 @@
+import type { SvelteHTMLElements } from "svelte/elements";
+export type FieldsetProps<TTag extends keyof SvelteHTMLElements = typeof DEFAULT_FIELDSET_TAG> = SvelteHTMLElements[TTag] & {
+    as?: TTag;
+    disabled?: boolean;
+    children?: Snippet<[
+        {
+            disabled: boolean;
+        }
+    ]>;
+};
+declare const DEFAULT_FIELDSET_TAG: "fieldset";
+import { type Snippet } from "svelte";
+declare class __sveltets_Render<TTag extends keyof SvelteHTMLElements> {
+    props(): FieldsetProps<TTag>;
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TTag extends keyof SvelteHTMLElements>(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 keyof SvelteHTMLElements>(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 Fieldset: $$IsomorphicComponent;
+type Fieldset<TTag extends keyof SvelteHTMLElements> = InstanceType<typeof Fieldset<TTag>>;
+export default Fieldset;

package/dist/fieldset/index.d.ts

@@ -0,0 +1 @@
+export { default as Fieldset, type FieldsetProps } from "./Fieldset.svelte";

package/dist/fieldset/index.js

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

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./checkbox/index.js";
+export * from "./description/index.js";
+export * from "./field/index.js";
+export * from "./fieldset/index.js";
+export * from "./label/index.js";
+export * from "./legend/index.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./checkbox/index.js";
+export * from "./description/index.js";
+export * from "./field/index.js";
+export * from "./fieldset/index.js";
+export * from "./label/index.js";
+export * from "./legend/index.js";