@funstack/ui 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/select/select-option.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-option.mjs","names":[],"sources":["../../src/select/select-option.tsx"],"sourcesContent":["\"use client\";\nimport { useEffectEvent, useLayoutEffect } from \"react\";\nimport type { ComponentPropsWithRef, CSSProperties, ReactNode } from \"react\";\nimport { dataAttr } from \"../internal/data-attr.js\";\nimport { syncPresence } from \"../internal/sync-presence.js\";\nimport type { RenderProp, StateValue } from \"../internal/types.js\";\nimport { useHydratedMount } from \"../internal/use-hydrated-mount.js\";\nimport { useRender } from \"../internal/use-render.js\";\nimport { useSelectContext } from \"./select-context.js\";\nimport { useSelectPartRef } from \"./select-dom.js\";\n\nexport interface SelectOptionState {\n  readonly value: string;\n  /** Optimistic: true as soon as the user picks this option, before the action settles. */\n  readonly selected: boolean;\n  /** The Root is pending and this option is the optimistic target. */\n  readonly pending: boolean;\n  /** Disabled by its own prop, a disabled `Select.Group`, or `Root disabled` (as `:disabled`). */\n  readonly disabled: boolean;\n}\n\nexport interface SelectOptionProps extends Omit<\n  ComponentPropsWithRef<\"option\">,\n  \"value\" | \"selected\" | \"className\" | \"style\" | \"children\"\n> {\n  /** The option's value. Required: React cannot infer a value from rich children. */\n  value: string;\n  /** Native `disabled`: not pickable, skipped by keyboard navigation. */\n  disabled?: boolean;\n  className?: StateValue<string | undefined, SelectOptionState>;\n  style?: StateValue<CSSProperties | undefined, SelectOptionState>;\n  /**\n   * The option's content. Keep it readable as plain text: engines without customizable select\n   * (Firefox today) show only the text. Give icons `aria-hidden` and no text. Avoid the `label`\n   * attribute (Chromium names the option from it but shows the content).\n   */\n  children?: StateValue<ReactNode, SelectOptionState>;\n  /** Replace the rendered element. Must keep an `<option>`. */\n  render?: RenderProp<ComponentPropsWithRef<\"option\">, SelectOptionState>;\n}\n\n/**\n * One `<option>`. It never renders `selected`: the selection is the Root's `value={optimistic}`\n * plus the Root's re-apply for options that mount after the select's own commit (a Suspense\n * boundary or `use()` inside the select), which the Option reports from its mount layout effect.\n *\n * Owned keys: `value`, `selected` (never rendered), `disabled`, `data-selected`, `data-pending`,\n * `data-disabled`.\n */\nexport function SelectOption({\n  value,\n  disabled: disabledProp = false,\n  className,\n  style,\n  children,\n  render,\n  ...rest\n}: SelectOptionProps) {\n  const ctx = useSelectContext(\"Select.Option\");\n  const selected = ctx.optimistic === value;\n  const pending = ctx.pending && selected;\n  const disabled = ctx.disabled || ctx.groupDisabled || disabledProp;\n  const hydrated = useHydratedMount();\n  const { ref, node } = useSelectPartRef<HTMLOptionElement>(\"Select.Option\", \"option\");\n\n  // Reads the mount render's values: for a hydrated option that is the hydration render, which\n  // used the server snapshot (`hydrated === true`).\n  const reportMount = useEffectEvent(() => {\n    const el = node.current;\n    if (el !== null) {\n      // Hydration keeps server attributes that differ from the client render (React only warns);\n      // an option hydrating after its Root can render a different state than the server did.\n      syncPresence(el, \"data-selected\", selected);\n      syncPresence(el, \"data-pending\", pending);\n      syncPresence(el, \"data-disabled\", disabled);\n    }\n    ctx.optionMounted(el, hydrated);\n  });\n  useLayoutEffect(() => {\n    reportMount();\n  }, []);\n\n  const state: SelectOptionState = { value, selected, pending, disabled };\n\n  return useRender<ComponentPropsWithRef<\"option\">, SelectOptionState>({\n    defaultElement: \"option\",\n    render,\n    state,\n    className,\n    style,\n    children,\n    props: rest,\n    libraryProps: {\n      value,\n      selected: undefined,\n      // Only the Option's own prop: `Root disabled` and the Group disable natively themselves.\n      disabled: disabledProp,\n      \"data-selected\": dataAttr(selected),\n      \"data-pending\": dataAttr(pending),\n      \"data-disabled\": dataAttr(disabled),\n    },\n    ref,\n  });\n}\n\nSelectOption.displayName = \"SelectOption\";\n"],"mappings":";;;;;;;;;;;;;;;;;AAiDA,SAAgB,aAAa,EAC3B,OACA,UAAU,eAAe,OACzB,WACA,OACA,UACA,QACA,GAAG,QACiB;CACpB,MAAM,MAAM,iBAAiB,eAAe;CAC5C,MAAM,WAAW,IAAI,eAAe;CACpC,MAAM,UAAU,IAAI,WAAW;CAC/B,MAAM,WAAW,IAAI,YAAY,IAAI,iBAAiB;CACtD,MAAM,WAAW,iBAAiB;CAClC,MAAM,EAAE,KAAK,SAAS,iBAAoC,iBAAiB,QAAQ;CAInF,MAAM,cAAc,qBAAqB;EACvC,MAAM,KAAK,KAAK;EAChB,IAAI,OAAO,MAAM;GAGf,aAAa,IAAI,iBAAiB,QAAQ;GAC1C,aAAa,IAAI,gBAAgB,OAAO;GACxC,aAAa,IAAI,iBAAiB,QAAQ;EAC5C;EACA,IAAI,cAAc,IAAI,QAAQ;CAChC,CAAC;CACD,sBAAsB;EACpB,YAAY;CACd,GAAG,CAAC,CAAC;CAIL,OAAO,UAA8D;EACnE,gBAAgB;EAChB;EACA,OAAA;GALiC;GAAO;GAAU;GAAS;EAKvD;EACJ;EACA;EACA;EACA,OAAO;EACP,cAAc;GACZ;GACA,UAAU,KAAA;GAEV,UAAU;GACV,iBAAiB,SAAS,QAAQ;GAClC,gBAAgB,SAAS,OAAO;GAChC,iBAAiB,SAAS,QAAQ;EACpC;EACA;CACF,CAAC;AACH;AAEA,aAAa,cAAc"}

package/dist/select/select-root.d.mts

@@ -0,0 +1,66 @@
+import { ActionDetails, ChangeAction, ChangeReason, RenderProp, StateValue } from "../internal/types.mjs";
+import { CSSProperties, ComponentPropsWithRef, ReactNode } from "react";
+//#region src/select/select-root.d.ts
+/** Details passed as the second argument of `valueChangeAction`. */
+export interface SelectValueChangeDetails extends ActionDetails {
+  /**
+   * `"activate"`: the user picked an option (pointer, keyboard, typeahead, or browser autofill,
+   * which the library cannot tell from a pick); `details.event` is the native `change` event.
+   * `"platform"`: the browser changed the value without a pick the library saw: a form reset
+   * (`details.event` is the `reset` event), or a pick before hydration / Firefox form-state
+   * restoration reconciled at mount (`details.event` is `undefined`).
+   */
+  readonly reason: ChangeReason;
+}
+export interface SelectRootState {
+  /** Optimistic value. Content rendered from it must not suspend. */
+  readonly value: string;
+  /** An action dispatched through this Select is in flight. */
+  readonly pending: boolean;
+  /** The `disabled` prop. */
+  readonly disabled: boolean;
+}
+export interface SelectRootProps extends Omit<ComponentPropsWithRef<"select">, "value" | "defaultValue" | "onChange" | "multiple" | "size" | "disabled" | "className" | "style" | "children"> {
+  /** Controlled value. `undefined` means uncontrolled. Use `""` for the placeholder option. */
+  value?: string;
+  /**
+   * Initial value in uncontrolled mode, and the value a form reset returns to (the latest prop is
+   * mirrored into the options' `defaultSelected`). When omitted, the browser's choice (an option
+   * whose value is `""`, else the first enabled option) is adopted at mount, without a dispatch,
+   * and is what a form reset returns to. Until a pick (or a platform change) sets the value,
+   * options that mount later without the adopted one (a Suspense fallback) adopt again.
+   */
+  defaultValue?: string;
+  /**
+   * Runs inside the Root's transition whenever the selected option changes. May be sync or async
+   * (also a Server Function); rejections reach the nearest Error Boundary and roll the selection
+   * back.
+   *
+   * In engines whose closed select changes the value on every arrow press (Firefox, Safari with
+   * native appearance), every press dispatches; the latest dispatch wins. A `setState` placed
+   * after your own `await` is not a Transition update; wrap it in `startTransition` (React
+   * limitation). Controlled mode is the way to veto a change.
+   */
+  valueChangeAction?: ChangeAction<string, SelectValueChangeDetails>;
+  /** Native `disabled`. Never set by the library while pending. */
+  disabled?: boolean;
+  className?: StateValue<string | undefined, SelectRootState>;
+  style?: StateValue<CSSProperties | undefined, SelectRootState>;
+  children?: StateValue<ReactNode, SelectRootState>;
+  /** Replace the rendered element. Must keep a `<select>`. */
+  render?: RenderProp<ComponentPropsWithRef<"select">, SelectRootState>;
+}
+/**
+ * The `<select>` itself: owns the value, the transition, the form-reset listener, the mount
+ * reconciliation and the re-apply of late options (design/components/select.md 15.2). Renders
+ * `value={optimistic}`: react-dom restores a controlled select to its props after every event,
+ * and only the sync-lane optimistic value survives that restore.
+ *
+ * Owned keys (conventions 1.2): `value`, `disabled`, `data-pending`, `data-disabled`, `onChange`.
+ */
+export declare function SelectRoot({ value, defaultValue, valueChangeAction, disabled, className, style, children, render, ...rest }: SelectRootProps): import("react").JSX.Element;
+export declare namespace SelectRoot {
+  var displayName: string;
+}
+//#endregion
+//# sourceMappingURL=select-root.d.mts.map

package/dist/select/select-root.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-root.d.mts","names":[],"sources":["../../src/select/select-root.tsx"],"mappings":";;;;iBAqBiB,iCAAiC;;;;;;;;WAQvC,QAAQ;;iBAGF;;WAEN;;WAEA;;WAEA;;iBAGM,wBAAwB,KACvC;;EAYA;;;;;;;;EAQA;;;;;;;;;;;EAWA,oBAAoB,qBAAqB;;EAEzC;EACA,YAAY,+BAA+B;EAC3C,QAAQ,WAAW,2BAA2B;EAC9C,WAAW,WAAW,WAAW;;EAEjC,SAAS,WAAW,iCAAiC;;;;;;;;;;wBAWvC,aACd,OACA,cACA,mBACA,UACA,WACA,OACA,UACA,WACG,QACF,kCAAe,IAAA;yBAVF"}

package/dist/select/select-root.mjs

@@ -0,0 +1,94 @@
+"use client";
+import { createActionDetails } from "../internal/action-details.mjs";
+import { dataAttr } from "../internal/data-attr.mjs";
+import { transitionTypes } from "../internal/transition-types.mjs";
+import { useControllableAction } from "../internal/use-controllable-action.mjs";
+import { useRender } from "../internal/use-render.mjs";
+import { SelectContext } from "./select-context.mjs";
+import { useSelectPartRef } from "./select-dom.mjs";
+import { useNativeSelectValue } from "../internal/use-native-select-value.mjs";
+import { useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/select/select-root.tsx
+/**
+* The `<select>` itself: owns the value, the transition, the form-reset listener, the mount
+* reconciliation and the re-apply of late options (design/components/select.md 15.2). Renders
+* `value={optimistic}`: react-dom restores a controlled select to its props after every event,
+* and only the sync-lane optimistic value survives that restore.
+*
+* Owned keys (conventions 1.2): `value`, `disabled`, `data-pending`, `data-disabled`, `onChange`.
+*/
+function SelectRoot({ value, defaultValue, valueChangeAction, disabled = false, className, style, children, render, ...rest }) {
+	const { ref: libraryRef, node: selectRef } = useSelectPartRef("Select.Root", "select");
+	const { optimistic, pending, dispatch, latestInFlight, adopt } = useControllableAction({
+		controlled: value,
+		defaultValue,
+		initialValue: "",
+		action: valueChangeAction,
+		transitionTypes: () => transitionTypes("select"),
+		warn: {
+			component: "Select.Root",
+			prop: "value"
+		}
+	});
+	const [mountValue] = useState(value);
+	const resetTarget = value === void 0 ? defaultValue : mountValue ?? value;
+	const established = useRef(false);
+	const dispatchChange = (next, details) => {
+		established.current = true;
+		dispatch(next, details);
+	};
+	const { optionMounted } = useNativeSelectValue({
+		ref: selectRef,
+		optimistic,
+		latestInFlight,
+		resetTarget,
+		adoptDefault: value === void 0 && defaultValue === void 0 ? {
+			adopt,
+			established: () => established.current
+		} : void 0,
+		onPlatformChange: (next, event) => dispatchChange(next, createActionDetails(event, { reason: "platform" }))
+	});
+	const context = {
+		optimistic,
+		pending,
+		disabled,
+		groupDisabled: false,
+		optionMounted
+	};
+	const element = useRender({
+		defaultElement: "select",
+		render,
+		state: {
+			value: optimistic,
+			pending,
+			disabled
+		},
+		className,
+		style,
+		children,
+		props: rest,
+		libraryProps: {
+			value: optimistic,
+			disabled,
+			"data-pending": dataAttr(pending),
+			"data-disabled": dataAttr(disabled),
+			onChange: (event) => {
+				if (disabled) return;
+				const next = event.currentTarget.value;
+				if (next === optimistic) return;
+				dispatchChange(next, createActionDetails(event.nativeEvent, { reason: "activate" }));
+			}
+		},
+		ref: libraryRef
+	});
+	return /* @__PURE__ */ jsx(SelectContext, {
+		value: context,
+		children: element
+	});
+}
+SelectRoot.displayName = "SelectRoot";
+//#endregion
+export { SelectRoot };
+
+//# sourceMappingURL=select-root.mjs.map

package/dist/select/select-root.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-root.mjs","names":[],"sources":["../../src/select/select-root.tsx"],"sourcesContent":["\"use client\";\nimport { useRef, useState } from \"react\";\nimport type { ChangeEvent, ComponentPropsWithRef, CSSProperties, ReactNode } from \"react\";\nimport { createActionDetails } from \"../internal/action-details.js\";\nimport { dataAttr } from \"../internal/data-attr.js\";\nimport { transitionTypes } from \"../internal/transition-types.js\";\nimport type {\n  ActionDetails,\n  ChangeAction,\n  ChangeReason,\n  RenderProp,\n  StateValue,\n} from \"../internal/types.js\";\nimport { useControllableAction } from \"../internal/use-controllable-action.js\";\nimport { useNativeSelectValue } from \"../internal/use-native-select-value.js\";\nimport { useRender } from \"../internal/use-render.js\";\nimport { SelectContext } from \"./select-context.js\";\nimport type { SelectContextValue } from \"./select-context.js\";\nimport { useSelectPartRef } from \"./select-dom.js\";\n\n/** Details passed as the second argument of `valueChangeAction`. */\nexport interface SelectValueChangeDetails extends ActionDetails {\n  /**\n   * `\"activate\"`: the user picked an option (pointer, keyboard, typeahead, or browser autofill,\n   * which the library cannot tell from a pick); `details.event` is the native `change` event.\n   * `\"platform\"`: the browser changed the value without a pick the library saw: a form reset\n   * (`details.event` is the `reset` event), or a pick before hydration / Firefox form-state\n   * restoration reconciled at mount (`details.event` is `undefined`).\n   */\n  readonly reason: ChangeReason;\n}\n\nexport interface SelectRootState {\n  /** Optimistic value. Content rendered from it must not suspend. */\n  readonly value: string;\n  /** An action dispatched through this Select is in flight. */\n  readonly pending: boolean;\n  /** The `disabled` prop. */\n  readonly disabled: boolean;\n}\n\nexport interface SelectRootProps extends Omit<\n  ComponentPropsWithRef<\"select\">,\n  | \"value\"\n  | \"defaultValue\"\n  | \"onChange\"\n  | \"multiple\"\n  | \"size\"\n  | \"disabled\"\n  | \"className\"\n  | \"style\"\n  | \"children\"\n> {\n  /** Controlled value. `undefined` means uncontrolled. Use `\"\"` for the placeholder option. */\n  value?: string;\n  /**\n   * Initial value in uncontrolled mode, and the value a form reset returns to (the latest prop is\n   * mirrored into the options' `defaultSelected`). When omitted, the browser's choice (an option\n   * whose value is `\"\"`, else the first enabled option) is adopted at mount, without a dispatch,\n   * and is what a form reset returns to. Until a pick (or a platform change) sets the value,\n   * options that mount later without the adopted one (a Suspense fallback) adopt again.\n   */\n  defaultValue?: string;\n  /**\n   * Runs inside the Root's transition whenever the selected option changes. May be sync or async\n   * (also a Server Function); rejections reach the nearest Error Boundary and roll the selection\n   * back.\n   *\n   * In engines whose closed select changes the value on every arrow press (Firefox, Safari with\n   * native appearance), every press dispatches; the latest dispatch wins. A `setState` placed\n   * after your own `await` is not a Transition update; wrap it in `startTransition` (React\n   * limitation). Controlled mode is the way to veto a change.\n   */\n  valueChangeAction?: ChangeAction<string, SelectValueChangeDetails>;\n  /** Native `disabled`. Never set by the library while pending. */\n  disabled?: boolean;\n  className?: StateValue<string | undefined, SelectRootState>;\n  style?: StateValue<CSSProperties | undefined, SelectRootState>;\n  children?: StateValue<ReactNode, SelectRootState>;\n  /** Replace the rendered element. Must keep a `<select>`. */\n  render?: RenderProp<ComponentPropsWithRef<\"select\">, SelectRootState>;\n}\n\n/**\n * The `<select>` itself: owns the value, the transition, the form-reset listener, the mount\n * reconciliation and the re-apply of late options (design/components/select.md 15.2). Renders\n * `value={optimistic}`: react-dom restores a controlled select to its props after every event,\n * and only the sync-lane optimistic value survives that restore.\n *\n * Owned keys (conventions 1.2): `value`, `disabled`, `data-pending`, `data-disabled`, `onChange`.\n */\nexport function SelectRoot({\n  value,\n  defaultValue,\n  valueChangeAction,\n  disabled = false,\n  className,\n  style,\n  children,\n  render,\n  ...rest\n}: SelectRootProps) {\n  const { ref: libraryRef, node: selectRef } = useSelectPartRef<HTMLSelectElement>(\n    \"Select.Root\",\n    \"select\",\n  );\n\n  const { optimistic, pending, dispatch, latestInFlight, adopt } = useControllableAction<\n    string,\n    SelectValueChangeDetails\n  >({\n    controlled: value,\n    defaultValue,\n    initialValue: \"\",\n    action: valueChangeAction,\n    transitionTypes: () => transitionTypes(\"select\"),\n    warn: { component: \"Select.Root\", prop: \"value\" },\n  });\n  // Deliberately no warning when neither `value` nor `defaultValue` is given: the browser's\n  // first-option default is adopted (design decision 3, product-owner decision 4).\n\n  // Controlled: the mount-time value is the reset target (conventions 3.8 rule 6). Neither\n  // `value` nor `defaultValue`: the value adopted at mount, chosen inside the hook.\n  const [mountValue] = useState(value);\n  const resetTarget = value === undefined ? defaultValue : (mountValue ?? value);\n\n  // Any dispatch, a pick or a platform change, ends the adoption of the browser's default.\n  const established = useRef(false);\n  const dispatchChange = (next: string, details: SelectValueChangeDetails) => {\n    established.current = true;\n    dispatch(next, details);\n  };\n\n  const { optionMounted } = useNativeSelectValue({\n    ref: selectRef,\n    optimistic,\n    latestInFlight,\n    resetTarget,\n    adoptDefault:\n      value === undefined && defaultValue === undefined\n        ? { adopt, established: () => established.current }\n        : undefined,\n    onPlatformChange: (next, event) =>\n      dispatchChange(next, createActionDetails(event, { reason: \"platform\" })),\n  });\n\n  const context: SelectContextValue = {\n    optimistic,\n    pending,\n    disabled,\n    groupDisabled: false,\n    optionMounted,\n  };\n  const state: SelectRootState = { value: optimistic, pending, disabled };\n\n  const element = useRender<ComponentPropsWithRef<\"select\">, SelectRootState>({\n    defaultElement: \"select\",\n    render,\n    state,\n    className,\n    style,\n    children,\n    props: rest,\n    libraryProps: {\n      value: optimistic,\n      disabled,\n      \"data-pending\": dataAttr(pending),\n      \"data-disabled\": dataAttr(disabled),\n      onChange: (event: ChangeEvent<HTMLSelectElement>) => {\n        // A natively disabled select fires no change; this covers `render` elements.\n        if (disabled) return;\n        const next = event.currentTarget.value;\n        // No-op rule against the optimistic value (conventions 2.3, design 4.2).\n        if (next === optimistic) return;\n        dispatchChange(next, createActionDetails(event.nativeEvent, { reason: \"activate\" }));\n      },\n    },\n    ref: libraryRef,\n  });\n\n  return <SelectContext value={context}>{element}</SelectContext>;\n}\n\nSelectRoot.displayName = \"SelectRoot\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA2FA,SAAgB,WAAW,EACzB,OACA,cACA,mBACA,WAAW,OACX,WACA,OACA,UACA,QACA,GAAG,QACe;CAClB,MAAM,EAAE,KAAK,YAAY,MAAM,cAAc,iBAC3C,eACA,QACF;CAEA,MAAM,EAAE,YAAY,SAAS,UAAU,gBAAgB,UAAU,sBAG/D;EACA,YAAY;EACZ;EACA,cAAc;EACd,QAAQ;EACR,uBAAuB,gBAAgB,QAAQ;EAC/C,MAAM;GAAE,WAAW;GAAe,MAAM;EAAQ;CAClD,CAAC;CAMD,MAAM,CAAC,cAAc,SAAS,KAAK;CACnC,MAAM,cAAc,UAAU,KAAA,IAAY,eAAgB,cAAc;CAGxE,MAAM,cAAc,OAAO,KAAK;CAChC,MAAM,kBAAkB,MAAc,YAAsC;EAC1E,YAAY,UAAU;EACtB,SAAS,MAAM,OAAO;CACxB;CAEA,MAAM,EAAE,kBAAkB,qBAAqB;EAC7C,KAAK;EACL;EACA;EACA;EACA,cACE,UAAU,KAAA,KAAa,iBAAiB,KAAA,IACpC;GAAE;GAAO,mBAAmB,YAAY;EAAQ,IAChD,KAAA;EACN,mBAAmB,MAAM,UACvB,eAAe,MAAM,oBAAoB,OAAO,EAAE,QAAQ,WAAW,CAAC,CAAC;CAC3E,CAAC;CAED,MAAM,UAA8B;EAClC;EACA;EACA;EACA,eAAe;EACf;CACF;CAGA,MAAM,UAAU,UAA4D;EAC1E,gBAAgB;EAChB;EACA,OAAA;GAL+B,OAAO;GAAY;GAAS;EAKvD;EACJ;EACA;EACA;EACA,OAAO;EACP,cAAc;GACZ,OAAO;GACP;GACA,gBAAgB,SAAS,OAAO;GAChC,iBAAiB,SAAS,QAAQ;GAClC,WAAW,UAA0C;IAEnD,IAAI,UAAU;IACd,MAAM,OAAO,MAAM,cAAc;IAEjC,IAAI,SAAS,YAAY;IACzB,eAAe,MAAM,oBAAoB,MAAM,aAAa,EAAE,QAAQ,WAAW,CAAC,CAAC;GACrF;EACF;EACA,KAAK;CACP,CAAC;CAED,OAAO,oBAAC,eAAD;EAAe,OAAO;EAAU,UAAA;CAAuB,CAAA;AAChE;AAEA,WAAW,cAAc"}

package/dist/select/select-separator.d.mts

@@ -0,0 +1,20 @@
+import { RenderProp, StateValue } from "../internal/types.mjs";
+import { SelectRootState } from "./select-root.mjs";
+import { CSSProperties, ComponentPropsWithRef } from "react";
+//#region src/select/select-separator.d.ts
+export interface SelectSeparatorProps extends Omit<ComponentPropsWithRef<"hr">, "className" | "style" | "children"> {
+  className?: StateValue<string | undefined, SelectRootState>;
+  style?: StateValue<CSSProperties | undefined, SelectRootState>;
+  /** Replace the rendered element. */
+  render?: RenderProp<ComponentPropsWithRef<"hr">, SelectRootState>;
+}
+/**
+ * A decorative `<hr>` between options or groups (exposed as `separator` by Chromium's
+ * customizable select; a line in native pickers). Owns no keys.
+ */
+export declare function SelectSeparator({ className, style, render, ...rest }: SelectSeparatorProps): import("react").ReactNode;
+export declare namespace SelectSeparator {
+  var displayName: string;
+}
+//#endregion
+//# sourceMappingURL=select-separator.d.mts.map

package/dist/select/select-separator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-separator.d.mts","names":[],"sources":["../../src/select/select-separator.tsx"],"mappings":";;;;iBAOiB,6BAA6B,KAC5C;EAGA,YAAY,+BAA+B;EAC3C,QAAQ,WAAW,2BAA2B;;EAE9C,SAAS,WAAW,6BAA6B;;;;;;wBAOnC,kBAAkB,WAAW,OAAO,WAAW,QAAQ,uCAAoB;yBAA3E"}

package/dist/select/select-separator.mjs

@@ -0,0 +1,30 @@
+"use client";
+import { useRender } from "../internal/use-render.mjs";
+import { useSelectContext } from "./select-context.mjs";
+//#region src/select/select-separator.tsx
+/**
+* A decorative `<hr>` between options or groups (exposed as `separator` by Chromium's
+* customizable select; a line in native pickers). Owns no keys.
+*/
+function SelectSeparator({ className, style, render, ...rest }) {
+	const ctx = useSelectContext("Select.Separator");
+	const state = {
+		value: ctx.optimistic,
+		pending: ctx.pending,
+		disabled: ctx.disabled
+	};
+	return useRender({
+		defaultElement: "hr",
+		render,
+		state,
+		className,
+		style,
+		children: void 0,
+		props: rest
+	});
+}
+SelectSeparator.displayName = "SelectSeparator";
+//#endregion
+export { SelectSeparator };
+
+//# sourceMappingURL=select-separator.mjs.map

package/dist/select/select-separator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-separator.mjs","names":[],"sources":["../../src/select/select-separator.tsx"],"sourcesContent":["\"use client\";\nimport type { ComponentPropsWithRef, CSSProperties } from \"react\";\nimport type { RenderProp, StateValue } from \"../internal/types.js\";\nimport { useRender } from \"../internal/use-render.js\";\nimport { useSelectContext } from \"./select-context.js\";\nimport type { SelectRootState } from \"./select-root.js\";\n\nexport interface SelectSeparatorProps extends Omit<\n  ComponentPropsWithRef<\"hr\">,\n  \"className\" | \"style\" | \"children\"\n> {\n  className?: StateValue<string | undefined, SelectRootState>;\n  style?: StateValue<CSSProperties | undefined, SelectRootState>;\n  /** Replace the rendered element. */\n  render?: RenderProp<ComponentPropsWithRef<\"hr\">, SelectRootState>;\n}\n\n/**\n * A decorative `<hr>` between options or groups (exposed as `separator` by Chromium's\n * customizable select; a line in native pickers). Owns no keys.\n */\nexport function SelectSeparator({ className, style, render, ...rest }: SelectSeparatorProps) {\n  const ctx = useSelectContext(\"Select.Separator\");\n  const state: SelectRootState = {\n    value: ctx.optimistic,\n    pending: ctx.pending,\n    disabled: ctx.disabled,\n  };\n  return useRender<ComponentPropsWithRef<\"hr\">, SelectRootState>({\n    defaultElement: \"hr\",\n    render,\n    state,\n    className,\n    style,\n    children: undefined,\n    props: rest,\n  });\n}\n\nSelectSeparator.displayName = \"SelectSeparator\";\n"],"mappings":";;;;;;;;AAqBA,SAAgB,gBAAgB,EAAE,WAAW,OAAO,QAAQ,GAAG,QAA8B;CAC3F,MAAM,MAAM,iBAAiB,kBAAkB;CAC/C,MAAM,QAAyB;EAC7B,OAAO,IAAI;EACX,SAAS,IAAI;EACb,UAAU,IAAI;CAChB;CACA,OAAO,UAAwD;EAC7D,gBAAgB;EAChB;EACA;EACA;EACA;EACA,UAAU,KAAA;EACV,OAAO;CACT,CAAC;AACH;AAEA,gBAAgB,cAAc"}

package/dist/select/select-trigger.d.mts

@@ -0,0 +1,29 @@
+import { RenderProp, StateValue } from "../internal/types.mjs";
+import { SelectRootState } from "./select-root.mjs";
+import { CSSProperties, ComponentPropsWithRef, ReactNode } from "react";
+//#region src/select/select-trigger.d.ts
+export interface SelectTriggerProps extends Omit<ComponentPropsWithRef<"button">, "type" | "className" | "style" | "children"> {
+  className?: StateValue<string | undefined, SelectRootState>;
+  style?: StateValue<CSSProperties | undefined, SelectRootState>;
+  /**
+   * Non-interactive content only (HTML content model of a select's button), usually
+   * `<Select.Value />`. Not rendered by engines without customizable select (Firefox today).
+   */
+  children?: StateValue<ReactNode, SelectRootState>;
+  /** Replace the rendered element. Must keep a `<button>`. */
+  render?: RenderProp<ComponentPropsWithRef<"button">, SelectRootState>;
+}
+/**
+ * The select's own `<button>` (customizable select): replaces the UA button in engines with
+ * `appearance: base-select`. Optional; **must be the first child** of `Select.Root`. Its state is
+ * the Root's state, so a pending indicator next to `<Select.Value />` goes in its function
+ * `children`.
+ *
+ * Owned keys: `type` (always `"button"`), `data-pending`, `data-disabled`.
+ */
+export declare function SelectTrigger({ className, style, children, render, ...rest }: SelectTriggerProps): ReactNode;
+export declare namespace SelectTrigger {
+  var displayName: string;
+}
+//#endregion
+//# sourceMappingURL=select-trigger.d.mts.map

package/dist/select/select-trigger.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-trigger.d.mts","names":[],"sources":["../../src/select/select-trigger.tsx"],"mappings":";;;;iBASiB,2BAA2B,KAC1C;EAGA,YAAY,+BAA+B;EAC3C,QAAQ,WAAW,2BAA2B;;;;;EAK9C,WAAW,WAAW,WAAW;;EAEjC,SAAS,WAAW,iCAAiC;;;;;;;;;;wBAoBvC,gBAAgB,WAAW,OAAO,UAAU,WAAW,QAAQ,qBAAkB;yBAAjF"}

package/dist/select/select-trigger.mjs

@@ -0,0 +1,48 @@
+"use client";
+import { dataAttr } from "../internal/data-attr.mjs";
+import { useRender } from "../internal/use-render.mjs";
+import { useSelectContext } from "./select-context.mjs";
+import { useSelectPartRef } from "./select-dom.mjs";
+//#region src/select/select-trigger.tsx
+function firstChildOfSelect(el) {
+	const parent = el.parentElement;
+	if (parent?.tagName === "SELECT" && parent.firstElementChild === el) return null;
+	return "must be the first child of Select.Root's <select> (HTML content model); elsewhere the browser does not use it as the select's button.";
+}
+/**
+* The select's own `<button>` (customizable select): replaces the UA button in engines with
+* `appearance: base-select`. Optional; **must be the first child** of `Select.Root`. Its state is
+* the Root's state, so a pending indicator next to `<Select.Value />` goes in its function
+* `children`.
+*
+* Owned keys: `type` (always `"button"`), `data-pending`, `data-disabled`.
+*/
+function SelectTrigger({ className, style, children, render, ...rest }) {
+	const ctx = useSelectContext("Select.Trigger");
+	const state = {
+		value: ctx.optimistic,
+		pending: ctx.pending,
+		disabled: ctx.disabled
+	};
+	const { ref } = useSelectPartRef("Select.Trigger", "button", firstChildOfSelect);
+	return useRender({
+		defaultElement: "button",
+		render,
+		state,
+		className,
+		style,
+		children,
+		props: rest,
+		libraryProps: {
+			type: "button",
+			"data-pending": dataAttr(ctx.pending),
+			"data-disabled": dataAttr(ctx.disabled)
+		},
+		ref
+	});
+}
+SelectTrigger.displayName = "SelectTrigger";
+//#endregion
+export { SelectTrigger };
+
+//# sourceMappingURL=select-trigger.mjs.map

package/dist/select/select-trigger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-trigger.mjs","names":[],"sources":["../../src/select/select-trigger.tsx"],"sourcesContent":["\"use client\";\nimport type { ComponentPropsWithRef, CSSProperties, ReactNode } from \"react\";\nimport { dataAttr } from \"../internal/data-attr.js\";\nimport type { RenderProp, StateValue } from \"../internal/types.js\";\nimport { useRender } from \"../internal/use-render.js\";\nimport { useSelectContext } from \"./select-context.js\";\nimport { useSelectPartRef } from \"./select-dom.js\";\nimport type { SelectRootState } from \"./select-root.js\";\n\nexport interface SelectTriggerProps extends Omit<\n  ComponentPropsWithRef<\"button\">,\n  \"type\" | \"className\" | \"style\" | \"children\"\n> {\n  className?: StateValue<string | undefined, SelectRootState>;\n  style?: StateValue<CSSProperties | undefined, SelectRootState>;\n  /**\n   * Non-interactive content only (HTML content model of a select's button), usually\n   * `<Select.Value />`. Not rendered by engines without customizable select (Firefox today).\n   */\n  children?: StateValue<ReactNode, SelectRootState>;\n  /** Replace the rendered element. Must keep a `<button>`. */\n  render?: RenderProp<ComponentPropsWithRef<\"button\">, SelectRootState>;\n}\n\nfunction firstChildOfSelect(el: HTMLButtonElement): string | null {\n  const parent = el.parentElement;\n  if (parent?.tagName === \"SELECT\" && parent.firstElementChild === el) return null;\n  return (\n    \"must be the first child of Select.Root's <select> (HTML content model); elsewhere the \" +\n    \"browser does not use it as the select's button.\"\n  );\n}\n\n/**\n * The select's own `<button>` (customizable select): replaces the UA button in engines with\n * `appearance: base-select`. Optional; **must be the first child** of `Select.Root`. Its state is\n * the Root's state, so a pending indicator next to `<Select.Value />` goes in its function\n * `children`.\n *\n * Owned keys: `type` (always `\"button\"`), `data-pending`, `data-disabled`.\n */\nexport function SelectTrigger({ className, style, children, render, ...rest }: SelectTriggerProps) {\n  const ctx = useSelectContext(\"Select.Trigger\");\n  const state: SelectRootState = {\n    value: ctx.optimistic,\n    pending: ctx.pending,\n    disabled: ctx.disabled,\n  };\n  const { ref } = useSelectPartRef<HTMLButtonElement>(\n    \"Select.Trigger\",\n    \"button\",\n    firstChildOfSelect,\n  );\n  return useRender<ComponentPropsWithRef<\"button\">, SelectRootState>({\n    defaultElement: \"button\",\n    render,\n    state,\n    className,\n    style,\n    children,\n    props: rest,\n    libraryProps: {\n      // Explicit: Chromium 156 reports `.type === \"submit\"` for a select's button.\n      type: \"button\",\n      \"data-pending\": dataAttr(ctx.pending),\n      \"data-disabled\": dataAttr(ctx.disabled),\n    },\n    ref,\n  });\n}\n\nSelectTrigger.displayName = \"SelectTrigger\";\n"],"mappings":";;;;;;AAwBA,SAAS,mBAAmB,IAAsC;CAChE,MAAM,SAAS,GAAG;CAClB,IAAI,QAAQ,YAAY,YAAY,OAAO,sBAAsB,IAAI,OAAO;CAC5E,OACE;AAGJ;;;;;;;;;AAUA,SAAgB,cAAc,EAAE,WAAW,OAAO,UAAU,QAAQ,GAAG,QAA4B;CACjG,MAAM,MAAM,iBAAiB,gBAAgB;CAC7C,MAAM,QAAyB;EAC7B,OAAO,IAAI;EACX,SAAS,IAAI;EACb,UAAU,IAAI;CAChB;CACA,MAAM,EAAE,QAAQ,iBACd,kBACA,UACA,kBACF;CACA,OAAO,UAA4D;EACjE,gBAAgB;EAChB;EACA;EACA;EACA;EACA;EACA,OAAO;EACP,cAAc;GAEZ,MAAM;GACN,gBAAgB,SAAS,IAAI,OAAO;GACpC,iBAAiB,SAAS,IAAI,QAAQ;EACxC;EACA;CACF,CAAC;AACH;AAEA,cAAc,cAAc"}

package/dist/select/select-value.d.mts

@@ -0,0 +1,31 @@
+import { RenderProp, StateValue } from "../internal/types.mjs";
+import { SelectRootState } from "./select-root.mjs";
+import { CSSProperties, ComponentPropsWithRef } from "react";
+//#region src/select/select-value.d.ts
+export interface SelectValueProps extends Omit<ComponentPropsWithRef<"selectedcontent">, "children" | "dangerouslySetInnerHTML" | "className" | "style"> {
+  className?: StateValue<string | undefined, SelectRootState>;
+  style?: StateValue<CSSProperties | undefined, SelectRootState>;
+  /** Replace the rendered element. Must keep a `<selectedcontent>`. */
+  render?: RenderProp<ComponentPropsWithRef<"selectedcontent">, SelectRootState>;
+}
+/**
+ * `<selectedcontent>`: the browser clones the selected option's content into it (inside
+ * `Select.Trigger`). It has no `children`. Rendered with `suppressHydrationWarning` and an empty
+ * `dangerouslySetInnerHTML` so that hydration accepts the content the parser cloned before React
+ * ran (design/components/select.md 3.3).
+ *
+ * Also keeps it fresh: the platform re-clones only on selection changes, so when React changes
+ * the selected option's content (a label, a state function, a Suspense boundary resolving inside
+ * it), a `MutationObserver` re-assigns `select.value = select.value`, which re-clones without
+ * events and without touching the selection or an open picker (6.3). The same refresh follows a
+ * form reset, which Chromium does not re-clone for. Not installed where
+ * `HTMLSelectedContentElement` is undefined (Firefox today, jsdom): nothing is cloned there.
+ *
+ * Owned keys: `dangerouslySetInnerHTML`, `suppressHydrationWarning`, `children`.
+ */
+export declare function SelectValue({ className, style, render, ...rest }: SelectValueProps): import("react").ReactNode;
+export declare namespace SelectValue {
+  var displayName: string;
+}
+//#endregion
+//# sourceMappingURL=select-value.d.mts.map

package/dist/select/select-value.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-value.d.mts","names":[],"sources":["../../src/select/select-value.tsx"],"mappings":";;;;iBAYiB,yBAAyB,KACxC;EAGA,YAAY,+BAA+B;EAC3C,QAAQ,WAAW,2BAA2B;;EAE9C,SAAS,WAAW,0CAA0C;;;;;;;;;;;;;;;;;wBA2ChD,cAAc,WAAW,OAAO,WAAW,QAAQ,mCAAgB;yBAAnE"}

package/dist/select/select-value.mjs

@@ -0,0 +1,101 @@
+"use client";
+import { useRender } from "../internal/use-render.mjs";
+import { useFormReset } from "../internal/use-form-reset.mjs";
+import { useSelectContext } from "./select-context.mjs";
+import { useSelectPartRef } from "./select-dom.mjs";
+import { useLayoutEffect, useMemo } from "react";
+//#region src/select/select-value.tsx
+const isDev = process.env.NODE_ENV !== "production";
+/** Where the browser clones options into `<selectedcontent>` (Chromium 135+, Safari 27). */
+function supportsSelectedContent() {
+	return typeof globalThis !== "undefined" && "HTMLSelectedContentElement" in globalThis;
+}
+/**
+* Whether a mutation record changes what `<selectedcontent>` shows: a record inside the selected
+* option. Attribute records on the option element itself are ignored (option attributes are not
+* cloned, and the library writes `data-*` there); records inside `<selectedcontent>` are never
+* inside an option, so the refresh's own clone does not loop.
+*/
+function touchesSelected(record, selected) {
+	if (record.type === "attributes" && record.target === selected) return false;
+	return selected.contains(record.target);
+}
+/** Re-clones the selected option into `<selectedcontent>`. */
+function refresh(select) {
+	if (select.selectedIndex === -1) return;
+	select.value = select.value;
+}
+/**
+* `<selectedcontent>`: the browser clones the selected option's content into it (inside
+* `Select.Trigger`). It has no `children`. Rendered with `suppressHydrationWarning` and an empty
+* `dangerouslySetInnerHTML` so that hydration accepts the content the parser cloned before React
+* ran (design/components/select.md 3.3).
+*
+* Also keeps it fresh: the platform re-clones only on selection changes, so when React changes
+* the selected option's content (a label, a state function, a Suspense boundary resolving inside
+* it), a `MutationObserver` re-assigns `select.value = select.value`, which re-clones without
+* events and without touching the selection or an open picker (6.3). The same refresh follows a
+* form reset, which Chromium does not re-clone for. Not installed where
+* `HTMLSelectedContentElement` is undefined (Firefox today, jsdom): nothing is cloned there.
+*
+* Owned keys: `dangerouslySetInnerHTML`, `suppressHydrationWarning`, `children`.
+*/
+function SelectValue({ className, style, render, ...rest }) {
+	const ctx = useSelectContext("Select.Value");
+	const { ref, node } = useSelectPartRef("Select.Value", "selectedcontent");
+	useLayoutEffect(() => {
+		const el = node.current;
+		if (el === null) return;
+		const select = el.closest("select");
+		if (select === null) {
+			if (isDev) console.error("Select.Value: rendered outside the Select.Root's <select>; put it inside Select.Trigger, the select's first child.");
+			return;
+		}
+		if (!supportsSelectedContent()) return;
+		const observer = new MutationObserver((records) => {
+			const selected = select.options[select.selectedIndex];
+			if (selected === void 0) return;
+			if (records.some((record) => touchesSelected(record, selected))) refresh(select);
+		});
+		observer.observe(select, {
+			childList: true,
+			characterData: true,
+			attributes: true,
+			subtree: true
+		});
+		return () => {
+			observer.disconnect();
+		};
+	}, [node]);
+	const selectRef = useMemo(() => ({ get current() {
+		return node.current?.closest("select") ?? null;
+	} }), [node]);
+	useFormReset(selectRef, () => {
+		const select = selectRef.current;
+		if (select !== null && supportsSelectedContent()) refresh(select);
+	});
+	const state = {
+		value: ctx.optimistic,
+		pending: ctx.pending,
+		disabled: ctx.disabled
+	};
+	return useRender({
+		defaultElement: "selectedcontent",
+		render,
+		state,
+		className,
+		style,
+		children: void 0,
+		props: rest,
+		libraryProps: {
+			suppressHydrationWarning: true,
+			dangerouslySetInnerHTML: { __html: "" }
+		},
+		ref
+	});
+}
+SelectValue.displayName = "SelectValue";
+//#endregion
+export { SelectValue };
+
+//# sourceMappingURL=select-value.mjs.map

package/dist/select/select-value.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-value.mjs","names":[],"sources":["../../src/select/select-value.tsx"],"sourcesContent":["\"use client\";\nimport { useLayoutEffect, useMemo } from \"react\";\nimport type { ComponentPropsWithRef, CSSProperties } from \"react\";\nimport type { RenderProp, StateValue } from \"../internal/types.js\";\nimport { useFormReset } from \"../internal/use-form-reset.js\";\nimport { useRender } from \"../internal/use-render.js\";\nimport { useSelectContext } from \"./select-context.js\";\nimport { useSelectPartRef } from \"./select-dom.js\";\nimport type { SelectRootState } from \"./select-root.js\";\n\nconst isDev = process.env.NODE_ENV !== \"production\";\n\nexport interface SelectValueProps extends Omit<\n  ComponentPropsWithRef<\"selectedcontent\">,\n  \"children\" | \"dangerouslySetInnerHTML\" | \"className\" | \"style\"\n> {\n  className?: StateValue<string | undefined, SelectRootState>;\n  style?: StateValue<CSSProperties | undefined, SelectRootState>;\n  /** Replace the rendered element. Must keep a `<selectedcontent>`. */\n  render?: RenderProp<ComponentPropsWithRef<\"selectedcontent\">, SelectRootState>;\n}\n\n/** Where the browser clones options into `<selectedcontent>` (Chromium 135+, Safari 27). */\nfunction supportsSelectedContent(): boolean {\n  return typeof globalThis !== \"undefined\" && \"HTMLSelectedContentElement\" in globalThis;\n}\n\n/**\n * Whether a mutation record changes what `<selectedcontent>` shows: a record inside the selected\n * option. Attribute records on the option element itself are ignored (option attributes are not\n * cloned, and the library writes `data-*` there); records inside `<selectedcontent>` are never\n * inside an option, so the refresh's own clone does not loop.\n */\nfunction touchesSelected(record: MutationRecord, selected: HTMLOptionElement): boolean {\n  if (record.type === \"attributes\" && record.target === selected) return false;\n  return selected.contains(record.target);\n}\n\n/** Re-clones the selected option into `<selectedcontent>`. */\nfunction refresh(select: HTMLSelectElement): void {\n  // Nothing selected: assigning the value would select the placeholder (probe case 7).\n  if (select.selectedIndex === -1) return;\n  // The assignment is the re-clone trigger; it fires no event and keeps the selection.\n  const current = select.value;\n  select.value = current;\n}\n\n/**\n * `<selectedcontent>`: the browser clones the selected option's content into it (inside\n * `Select.Trigger`). It has no `children`. Rendered with `suppressHydrationWarning` and an empty\n * `dangerouslySetInnerHTML` so that hydration accepts the content the parser cloned before React\n * ran (design/components/select.md 3.3).\n *\n * Also keeps it fresh: the platform re-clones only on selection changes, so when React changes\n * the selected option's content (a label, a state function, a Suspense boundary resolving inside\n * it), a `MutationObserver` re-assigns `select.value = select.value`, which re-clones without\n * events and without touching the selection or an open picker (6.3). The same refresh follows a\n * form reset, which Chromium does not re-clone for. Not installed where\n * `HTMLSelectedContentElement` is undefined (Firefox today, jsdom): nothing is cloned there.\n *\n * Owned keys: `dangerouslySetInnerHTML`, `suppressHydrationWarning`, `children`.\n */\nexport function SelectValue({ className, style, render, ...rest }: SelectValueProps) {\n  const ctx = useSelectContext(\"Select.Value\");\n  const { ref, node } = useSelectPartRef<HTMLElement>(\"Select.Value\", \"selectedcontent\");\n\n  useLayoutEffect(() => {\n    const el = node.current;\n    if (el === null) return;\n    const select = el.closest(\"select\");\n    if (select === null) {\n      if (isDev) {\n        console.error(\n          \"Select.Value: rendered outside the Select.Root's <select>; put it inside \" +\n            \"Select.Trigger, the select's first child.\",\n        );\n      }\n      return;\n    }\n    if (!supportsSelectedContent()) return;\n    const observer = new MutationObserver((records) => {\n      const selected = select.options[select.selectedIndex];\n      if (selected === undefined) return;\n      if (records.some((record) => touchesSelected(record, selected))) refresh(select);\n    });\n    observer.observe(select, {\n      childList: true,\n      characterData: true,\n      attributes: true,\n      subtree: true,\n    });\n    return () => {\n      observer.disconnect();\n    };\n  }, [node]);\n\n  // A form reset changes the selection without re-cloning (Chromium 156: `form.reset()` leaves\n  // the old option's content in <selectedcontent>; memo/developer/select.md). `useFormReset`\n  // listens on the select's form owner itself (so neither `stopPropagation()` on the form nor a\n  // shadow root hides the event), follows a changed owner or `form` attribute, and calls back in\n  // a microtask after an uncancelled reset. React's own reset after a form action is a\n  // `form.reset()` too.\n  const selectRef = useMemo(\n    () => ({\n      get current(): HTMLSelectElement | null {\n        return node.current?.closest(\"select\") ?? null;\n      },\n    }),\n    [node],\n  );\n  useFormReset(selectRef, () => {\n    const select = selectRef.current;\n    if (select !== null && supportsSelectedContent()) refresh(select);\n  });\n\n  const state: SelectRootState = {\n    value: ctx.optimistic,\n    pending: ctx.pending,\n    disabled: ctx.disabled,\n  };\n  return useRender<ComponentPropsWithRef<\"selectedcontent\">, SelectRootState>({\n    defaultElement: \"selectedcontent\",\n    render,\n    state,\n    className,\n    style,\n    children: undefined,\n    props: rest,\n    libraryProps: {\n      suppressHydrationWarning: true,\n      dangerouslySetInnerHTML: { __html: \"\" },\n    },\n    ref,\n  });\n}\n\nSelectValue.displayName = \"SelectValue\";\n"],"mappings":";;;;;;;AAUA,MAAM,QAAQ,QAAQ,IAAI,aAAa;;AAavC,SAAS,0BAAmC;CAC1C,OAAO,OAAO,eAAe,eAAe,gCAAgC;AAC9E;;;;;;;AAQA,SAAS,gBAAgB,QAAwB,UAAsC;CACrF,IAAI,OAAO,SAAS,gBAAgB,OAAO,WAAW,UAAU,OAAO;CACvE,OAAO,SAAS,SAAS,OAAO,MAAM;AACxC;;AAGA,SAAS,QAAQ,QAAiC;CAEhD,IAAI,OAAO,kBAAkB,IAAI;CAGjC,OAAO,QADS,OAAO;AAEzB;;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAY,EAAE,WAAW,OAAO,QAAQ,GAAG,QAA0B;CACnF,MAAM,MAAM,iBAAiB,cAAc;CAC3C,MAAM,EAAE,KAAK,SAAS,iBAA8B,gBAAgB,iBAAiB;CAErF,sBAAsB;EACpB,MAAM,KAAK,KAAK;EAChB,IAAI,OAAO,MAAM;EACjB,MAAM,SAAS,GAAG,QAAQ,QAAQ;EAClC,IAAI,WAAW,MAAM;GACnB,IAAI,OACF,QAAQ,MACN,oHAEF;GAEF;EACF;EACA,IAAI,CAAC,wBAAwB,GAAG;EAChC,MAAM,WAAW,IAAI,kBAAkB,YAAY;GACjD,MAAM,WAAW,OAAO,QAAQ,OAAO;GACvC,IAAI,aAAa,KAAA,GAAW;GAC5B,IAAI,QAAQ,MAAM,WAAW,gBAAgB,QAAQ,QAAQ,CAAC,GAAG,QAAQ,MAAM;EACjF,CAAC;EACD,SAAS,QAAQ,QAAQ;GACvB,WAAW;GACX,eAAe;GACf,YAAY;GACZ,SAAS;EACX,CAAC;EACD,aAAa;GACX,SAAS,WAAW;EACtB;CACF,GAAG,CAAC,IAAI,CAAC;CAQT,MAAM,YAAY,eACT,EACL,IAAI,UAAoC;EACtC,OAAO,KAAK,SAAS,QAAQ,QAAQ,KAAK;CAC5C,EACF,IACA,CAAC,IAAI,CACP;CACA,aAAa,iBAAiB;EAC5B,MAAM,SAAS,UAAU;EACzB,IAAI,WAAW,QAAQ,wBAAwB,GAAG,QAAQ,MAAM;CAClE,CAAC;CAED,MAAM,QAAyB;EAC7B,OAAO,IAAI;EACX,SAAS,IAAI;EACb,UAAU,IAAI;CAChB;CACA,OAAO,UAAqE;EAC1E,gBAAgB;EAChB;EACA;EACA;EACA;EACA,UAAU,KAAA;EACV,OAAO;EACP,cAAc;GACZ,0BAA0B;GAC1B,yBAAyB,EAAE,QAAQ,GAAG;EACxC;EACA;CACF,CAAC;AACH;AAEA,YAAY,cAAc"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@funstack/ui",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.2",
   "description": "Headless UI library for React — the first Async React-native UI library",
   "keywords": [
     "components",
@@ -32,10 +32,12 @@
     "./accordion": "./dist/accordion/index.mjs",
     "./checkbox": "./dist/checkbox/index.mjs",
     "./checkbox-group": "./dist/checkbox-group/index.mjs",
+    "./combobox": "./dist/combobox/index.mjs",
     "./dialog": "./dist/dialog/index.mjs",
     "./menu": "./dist/menu/index.mjs",
     "./popover": "./dist/popover/index.mjs",
     "./radio-group": "./dist/radio-group/index.mjs",
+    "./select": "./dist/select/index.mjs",
     "./switch": "./dist/switch/index.mjs",
     "./tabs": "./dist/tabs/index.mjs",
     "./toggle": "./dist/toggle/index.mjs",