@ui-sdk/react 0.0.0-stage → 0.1.0-beta.1

package/dist/separator.d.ts

@@ -0,0 +1,290 @@
+/**
+ * A line between groups of content, announced as a separator unless it's `decorative`.
+ * @stable
+ */
+declare const Separator: (props: import("@ui-sdk/core").OptionsOf<import("@ui-sdk/core/separator").SeparatorPrimitive> & import("@ui-sdk/core/renderer").BaseSlotProps & {
+    slot?: string | undefined | undefined;
+    style?: import("react").CSSProperties | ((state: NoInfer<import("@ui-sdk/core/separator").SeparatorState>) => React.CSSProperties | undefined) | undefined;
+    title?: string | undefined | undefined;
+    dir?: string | undefined | undefined;
+    "aria-labelledby"?: string | undefined | undefined;
+    "aria-label"?: string | undefined | undefined;
+    "aria-disabled"?: (boolean | "true" | "false") | undefined;
+    "aria-activedescendant"?: string | undefined | undefined;
+    "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined | undefined;
+    "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+    "aria-colcount"?: number | undefined | undefined;
+    "aria-colindex"?: number | undefined | undefined;
+    "aria-colspan"?: number | undefined | undefined;
+    "aria-expanded"?: (boolean | "true" | "false") | undefined;
+    "aria-level"?: number | undefined | undefined;
+    "aria-modal"?: (boolean | "true" | "false") | undefined;
+    "aria-multiline"?: (boolean | "true" | "false") | undefined;
+    "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+    "aria-orientation"?: "horizontal" | "vertical" | undefined | undefined;
+    "aria-placeholder"?: string | undefined | undefined;
+    "aria-posinset"?: number | undefined | undefined;
+    "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+    "aria-readonly"?: (boolean | "true" | "false") | undefined;
+    "aria-required"?: (boolean | "true" | "false") | undefined;
+    "aria-rowcount"?: number | undefined | undefined;
+    "aria-rowindex"?: number | undefined | undefined;
+    "aria-rowspan"?: number | undefined | undefined;
+    "aria-selected"?: (boolean | "true" | "false") | undefined;
+    "aria-setsize"?: number | undefined | undefined;
+    "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined | undefined;
+    "aria-valuemax"?: number | undefined | undefined;
+    "aria-valuemin"?: number | undefined | undefined;
+    "aria-valuenow"?: number | undefined | undefined;
+    "aria-valuetext"?: string | undefined | undefined;
+    role?: import("react").AriaRole | undefined;
+    key?: import("react").Key | null | undefined;
+    nonce?: string | undefined | undefined;
+    render?: import("./render-element.js").RenderProp<NoInfer<import("@ui-sdk/core/separator").SeparatorState>> | undefined;
+    property?: string | undefined | undefined;
+    "aria-description"?: string | undefined | undefined;
+    "aria-controls"?: string | undefined | undefined;
+    "aria-describedby"?: string | undefined | undefined;
+    "aria-details"?: string | undefined | undefined;
+    "aria-errormessage"?: string | undefined | undefined;
+    "aria-flowto"?: string | undefined | undefined;
+    "aria-owns"?: string | undefined | undefined;
+    part?: string | undefined | undefined;
+    hidden?: boolean | undefined | undefined;
+    defaultValue?: string | number | readonly string[] | undefined;
+    "aria-live"?: "off" | "assertive" | "polite" | undefined | undefined;
+    "aria-atomic"?: (boolean | "true" | "false") | undefined;
+    color?: string | undefined | undefined;
+    "aria-hidden"?: (boolean | "true" | "false") | undefined;
+    onChange?: import("react").ChangeEventHandler<HTMLDivElement, Element> | undefined;
+    lang?: string | undefined | undefined;
+    children?: import("react").ReactNode | ((state: NoInfer<import("@ui-sdk/core/separator").SeparatorState>) => React.ReactNode);
+    onScroll?: import("react").UIEventHandler<HTMLDivElement> | undefined;
+    popover?: "" | "auto" | "manual" | "hint" | undefined | undefined;
+    inert?: boolean | undefined | undefined;
+    content?: string | undefined | undefined;
+    translate?: "yes" | "no" | undefined | undefined;
+    results?: number | undefined | undefined;
+    "aria-busy"?: (boolean | "true" | "false") | undefined;
+    onSubmit?: import("react").SubmitEventHandler<HTMLDivElement> | undefined;
+    onBlur?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
+    onSelect?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    "aria-keyshortcuts"?: string | undefined | undefined;
+    "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined | undefined;
+    defaultChecked?: boolean | undefined | undefined;
+    accessKey?: string | undefined | undefined;
+    draggable?: (boolean | "true" | "false") | undefined;
+    className?: string | ((state: NoInfer<import("@ui-sdk/core/separator").SeparatorState>) => string | undefined) | undefined;
+    prefix?: string | undefined | undefined;
+    contentEditable?: "inherit" | (boolean | "true" | "false") | "plaintext-only" | undefined;
+    enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined | undefined;
+    inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined | undefined;
+    tabIndex?: number | undefined | undefined;
+    "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined | undefined;
+    "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined | undefined;
+    ref?: import("react").Ref<HTMLDivElement> | undefined;
+    onDoubleClick?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onFocus?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
+    suppressHydrationWarning?: boolean | undefined | undefined;
+    "aria-braillelabel"?: string | undefined | undefined;
+    "aria-brailleroledescription"?: string | undefined | undefined;
+    "aria-colindextext"?: string | undefined | undefined;
+    "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined | undefined;
+    "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+    "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined | undefined;
+    "aria-roledescription"?: string | undefined | undefined;
+    "aria-rowindextext"?: string | undefined | undefined;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined | undefined;
+    onCopy?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+    onCopyCapture?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+    onCut?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+    onCutCapture?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+    onPaste?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+    onPasteCapture?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+    onCompositionEnd?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+    onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+    onCompositionStart?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+    onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+    onCompositionUpdate?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+    onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+    onFocusCapture?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
+    onBlurCapture?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
+    onChangeCapture?: import("react").ChangeEventHandler<HTMLDivElement, Element> | undefined;
+    onBeforeInput?: import("react").InputEventHandler<HTMLDivElement> | undefined;
+    onBeforeInputCapture?: import("react").InputEventHandler<HTMLDivElement> | undefined;
+    onInput?: import("react").InputEventHandler<HTMLDivElement> | undefined;
+    onInputCapture?: import("react").InputEventHandler<HTMLDivElement> | undefined;
+    onReset?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onResetCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onSubmitCapture?: import("react").SubmitEventHandler<HTMLDivElement> | undefined;
+    onInvalid?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onInvalidCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onLoad?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onLoadCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onError?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onErrorCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onKeyDown?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+    onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+    onKeyPress?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+    onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+    onKeyUp?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+    onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+    onAbort?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onAbortCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onCanPlay?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onCanPlayCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onCanPlayThrough?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onDurationChange?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onDurationChangeCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onEmptied?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onEmptiedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onEncrypted?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onEncryptedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onEnded?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onEndedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onLoadedData?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onLoadedDataCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onLoadedMetadata?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onLoadStart?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onLoadStartCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onPause?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onPauseCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onPlay?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onPlayCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onPlaying?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onPlayingCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onProgress?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onProgressCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onRateChange?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onRateChangeCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onSeeked?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onSeekedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onSeeking?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onSeekingCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onStalled?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onStalledCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onSuspend?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onSuspendCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onTimeUpdate?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onVolumeChange?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onWaiting?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onWaitingCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onAuxClick?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onAuxClickCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onClick?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onClickCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onContextMenu?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onContextMenuCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onDoubleClickCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onDrag?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragEnd?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragEndCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragEnter?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragEnterCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragExit?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragExitCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragLeave?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragLeaveCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragOver?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragOverCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragStart?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragStartCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDrop?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDropCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onMouseDown?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseDownCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseEnter?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseLeave?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseMove?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseMoveCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseOut?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseOutCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseOver?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseOverCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseUp?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseUpCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onSelectCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onTouchCancel?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onTouchCancelCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onTouchEnd?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onTouchEndCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onTouchMove?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onTouchMoveCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onTouchStart?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onTouchStartCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onPointerDown?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerDownCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerMove?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerMoveCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerUp?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerUpCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerCancel?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerCancelCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerEnter?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerLeave?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerOver?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerOverCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerOut?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerOutCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onGotPointerCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onLostPointerCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onScrollCapture?: import("react").UIEventHandler<HTMLDivElement> | undefined;
+    onScrollEnd?: import("react").UIEventHandler<HTMLDivElement> | undefined;
+    onScrollEndCapture?: import("react").UIEventHandler<HTMLDivElement> | undefined;
+    onWheel?: import("react").WheelEventHandler<HTMLDivElement> | undefined;
+    onWheelCapture?: import("react").WheelEventHandler<HTMLDivElement> | undefined;
+    onAnimationStart?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+    onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+    onAnimationEnd?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+    onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+    onAnimationIteration?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+    onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+    onToggle?: import("react").ToggleEventHandler<HTMLDivElement> | undefined;
+    onBeforeToggle?: import("react").ToggleEventHandler<HTMLDivElement> | undefined;
+    onTransitionCancel?: import("react").TransitionEventHandler<HTMLDivElement> | undefined;
+    onTransitionCancelCapture?: import("react").TransitionEventHandler<HTMLDivElement> | undefined;
+    onTransitionEnd?: import("react").TransitionEventHandler<HTMLDivElement> | undefined;
+    onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLDivElement> | undefined;
+    onTransitionRun?: import("react").TransitionEventHandler<HTMLDivElement> | undefined;
+    onTransitionRunCapture?: import("react").TransitionEventHandler<HTMLDivElement> | undefined;
+    onTransitionStart?: import("react").TransitionEventHandler<HTMLDivElement> | undefined;
+    onTransitionStartCapture?: import("react").TransitionEventHandler<HTMLDivElement> | undefined;
+    suppressContentEditableWarning?: boolean | undefined | undefined;
+    autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {}) | undefined;
+    autoFocus?: boolean | undefined | undefined;
+    contextMenu?: string | undefined | undefined;
+    spellCheck?: (boolean | "true" | "false") | undefined;
+    radioGroup?: string | undefined | undefined;
+    about?: string | undefined | undefined;
+    datatype?: string | undefined | undefined;
+    inlist?: any;
+    rel?: string | undefined | undefined;
+    resource?: string | undefined | undefined;
+    rev?: string | undefined | undefined;
+    typeof?: string | undefined | undefined;
+    vocab?: string | undefined | undefined;
+    autoCorrect?: string | undefined | undefined;
+    autoSave?: string | undefined | undefined;
+    itemProp?: string | undefined | undefined;
+    itemScope?: boolean | undefined | undefined;
+    itemType?: string | undefined | undefined;
+    itemID?: string | undefined | undefined;
+    itemRef?: string | undefined | undefined;
+    security?: string | undefined | undefined;
+    unselectable?: "on" | "off" | undefined | undefined;
+    popoverTargetAction?: "toggle" | "show" | "hide" | undefined | undefined;
+    popoverTarget?: string | undefined | undefined;
+    is?: string | undefined | undefined;
+    exportparts?: string | undefined | undefined;
+}) => React.ReactElement | null;
+export { Separator };
+export type { SeparatorOptions, SeparatorOrientation, SeparatorPrimitive, SeparatorState, } from "@ui-sdk/core/separator";

package/dist/separator.js

@@ -0,0 +1,9 @@
+"use client";
+// src/separator.tsx
+import { separator } from "@ui-sdk/core/separator";
+import { createParts } from "./use-primitive.js";
+var parts = createParts(separator, { root: "div" });
+var Separator = parts.Root;
+export {
+  Separator
+};

package/dist/shortcuts.d.ts

@@ -0,0 +1,32 @@
+import { type ShortcutHandler, type ShortcutOptions } from "@ui-sdk/core/shortcuts";
+import * as React from "react";
+/**
+ * Options for `useShortcut`. `layer` also takes a ref, like one on an element inside a dialog.
+ * @stable
+ */
+type UseShortcutOptions = Omit<ShortcutOptions, "layer"> & {
+    /** An element inside a popup, a ref to one, or a function that returns one. The shortcut belongs to that popup. */
+    layer?: ShortcutOptions["layer"] | React.RefObject<Element | null>;
+};
+/**
+ * Registers a keyboard shortcut while the component is mounted, in the shared
+ * `shortcuts`. Keys like `"mod+k"`; nothing registers for `null`. The latest
+ * handler and `when` always run, so they needn't be stable.
+ * @stable
+ */
+declare function useShortcut(keys: string | null | undefined, handler: ShortcutHandler, options?: UseShortcutOptions): void;
+/**
+ * Keys formatted for this platform, like `⌘S` on Apple platforms and `Ctrl+S`
+ * elsewhere, with the matching `aria-keyshortcuts`. The server and the first
+ * client render use the same platform, so hydration matches, and it updates
+ * after mount. Calling `formatShortcut` during render instead differs between
+ * the server and a Mac.
+ * @stable
+ */
+declare function useShortcutHint(keys: string): {
+    text: string;
+    ariaKeyshortcuts: string;
+};
+export { ariaKeyshortcuts, formatShortcut, registerShortcut, shortcuts, } from "@ui-sdk/core/shortcuts";
+export type { ShortcutHandler, ShortcutInfo, ShortcutKeys, ShortcutOptions, Shortcuts, } from "@ui-sdk/core/shortcuts";
+export { useShortcut, useShortcutHint, type UseShortcutOptions };

package/dist/shortcuts.js

@@ -0,0 +1,61 @@
+"use client";
+// src/shortcuts.ts
+import { initialApple, isApple } from "@ui-sdk/core/renderer";
+import {
+  ariaKeyshortcuts,
+  formatShortcut,
+  shortcuts
+} from "@ui-sdk/core/shortcuts";
+import * as React from "react";
+import {
+  ariaKeyshortcuts as ariaKeyshortcuts2,
+  formatShortcut as formatShortcut2,
+  registerShortcut,
+  shortcuts as shortcuts2
+} from "@ui-sdk/core/shortcuts";
+function useShortcut(keys, handler, options = {}) {
+  const latest = React.useRef({ handler, options });
+  React.useLayoutEffect(() => {
+    latest.current = { handler, options };
+  });
+  const { scope, allowInInput, description } = options;
+  const conditional = !!options.when;
+  const layered = !!options.layer;
+  React.useEffect(() => {
+    if (!keys) {
+      return;
+    }
+    return shortcuts.register(keys, (event) => latest.current.handler(event), {
+      scope,
+      allowInInput,
+      description,
+      when: conditional ? () => latest.current.options.when?.() ?? true : void 0,
+      layer: layered ? () => {
+        const layer = latest.current.options.layer;
+        if (!layer) {
+          return null;
+        }
+        if (typeof layer === "function") {
+          return layer();
+        }
+        return "current" in layer ? layer.current : layer;
+      } : void 0
+    });
+  }, [keys, scope, allowInInput, description, layered, conditional]);
+}
+function useShortcutHint(keys) {
+  const [apple, setApple] = React.useState(initialApple);
+  React.useEffect(() => setApple(isApple()), []);
+  return {
+    text: formatShortcut(keys, apple),
+    ariaKeyshortcuts: ariaKeyshortcuts(keys, apple)
+  };
+}
+export {
+  ariaKeyshortcuts2 as ariaKeyshortcuts,
+  formatShortcut2 as formatShortcut,
+  registerShortcut,
+  shortcuts2 as shortcuts,
+  useShortcut,
+  useShortcutHint
+};

package/dist/slider.d.ts

@@ -0,0 +1,38 @@
+import { type SliderOptions, type SliderState, type SliderThumbProps, type SliderThumbState, type SliderValueState } from "@ui-sdk/core/slider";
+import * as React from "react";
+import { type PartProps } from "./use-primitive.js";
+type DivProps<State> = Omit<PartProps<"div", State>, "defaultValue" | "onChange" | "onSelect">;
+/**
+ * The root: a group around the thumbs, and the hidden input the form submits.
+ * @stable
+ */
+declare function Slider<Value extends number | number[] = number | number[]>({ value, defaultValue, onValueChange, onValueCommit, min, max, step, largeStep, minStepsBetweenThumbs, orientation, disabled, readOnly, required, name, form, format, locale, controller, debug, render, children, ...props }: SliderOptions<Value> & DivProps<SliderState>): React.JSX.Element;
+/**
+ * Where presses land. A press on the track moves the nearest thumb there.
+ * @stable
+ */
+declare const SliderControl: import("./use-primitive.js").PartComponent<import("@ui-sdk/core/slider").SliderPrimitive, "control", "div">;
+/**
+ * The rail the thumbs move along. Positions are percentages of it.
+ * @stable
+ */
+declare const SliderTrack: import("./use-primitive.js").PartComponent<import("@ui-sdk/core/slider").SliderPrimitive, "track", "div">;
+/**
+ * The filled part of the track: up to a single thumb, or between a range's thumbs.
+ * @stable
+ */
+declare const SliderIndicator: import("./use-primitive.js").PartComponent<import("@ui-sdk/core/slider").SliderPrimitive, "indicator", "div">;
+/**
+ * A thumb, with the native range input that takes focus inside it. Its
+ * `aria-label`, `aria-labelledby` and `aria-describedby` go to that input.
+ * @stable
+ */
+declare function SliderThumb({ index, children, "aria-label": label, "aria-labelledby": labelledBy, "aria-describedby": describedBy, ...props }: DivProps<SliderThumbState> & SliderThumbProps): React.JSX.Element | null;
+/**
+ * The formatted value, a range joined with an en dash. Children replace it.
+ * @stable
+ */
+declare function SliderValue({ children, ...props }: PartProps<"output", SliderValueState>): React.JSX.Element;
+export { createSliderController } from "@ui-sdk/core/slider";
+export type { NumberFormat, SliderApi, SliderChangeOptions, SliderController, SliderOptions, SliderPrimitive, SliderState, SliderThumbProps, SliderThumbState, SliderValueChangeDetails, SliderValueChangeReason, SliderValueCommitDetails, SliderValueState, } from "@ui-sdk/core/slider";
+export { Slider, SliderControl, SliderIndicator, SliderThumb, SliderTrack, SliderValue, };

package/dist/slider.js

@@ -0,0 +1,163 @@
+"use client";
+// src/slider.tsx
+import {
+  slider as sliderPrimitive
+} from "@ui-sdk/core/slider";
+import * as React from "react";
+import {
+  controlRender,
+  useFieldControl,
+  useFieldControlId
+} from "./field-context.js";
+import {
+  createParts,
+  extendHandle,
+  usePart,
+  usePrimitive
+} from "./use-primitive.js";
+import { createSliderController } from "@ui-sdk/core/slider";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var parts = createParts(sliderPrimitive, {
+  control: "div",
+  track: "div",
+  indicator: "div",
+  value: "output"
+});
+var SliderContext = React.createContext(null);
+function useSlider(part) {
+  const context = React.useContext(SliderContext);
+  if (!context) {
+    throw new Error(`${part} must be used inside <Slider>.`);
+  }
+  return context;
+}
+function withAfter(children, after) {
+  return (state) => /* @__PURE__ */ jsxs(Fragment, { children: [
+    typeof children === "function" ? children(state) : children,
+    after
+  ] });
+}
+function Slider({
+  value,
+  defaultValue,
+  onValueChange,
+  onValueCommit,
+  min,
+  max,
+  step,
+  largeStep,
+  minStepsBetweenThumbs,
+  orientation,
+  disabled,
+  readOnly,
+  required,
+  name,
+  form,
+  format,
+  locale,
+  controller,
+  debug,
+  render,
+  children,
+  ...props
+}) {
+  const field = useFieldControl();
+  const controlId = useFieldControlId();
+  const slider = usePrimitive(sliderPrimitive, {
+    value,
+    defaultValue,
+    onValueChange,
+    onValueCommit,
+    min,
+    max,
+    step,
+    largeStep,
+    minStepsBetweenThumbs,
+    orientation,
+    disabled: disabled || field?.disabled,
+    readOnly,
+    required,
+    name: name ?? field?.name,
+    form,
+    format,
+    locale,
+    controller,
+    debug,
+    thumbInputId: controlId
+  });
+  const shape = value ?? defaultValue;
+  const range = Array.isArray(shape) && shape.length > 1;
+  const context = React.useMemo(
+    () => extendHandle(slider, { field: range ? null : field }),
+    [slider, range, field]
+  );
+  const root = {
+    ...props,
+    children: withAfter(children, /* @__PURE__ */ jsx(HiddenInput, {})),
+    render: controlRender(range ? field : null, "div", render)
+  };
+  return /* @__PURE__ */ jsx(SliderContext.Provider, { value: context, children: usePart(slider, "root", {}, root) });
+}
+function HiddenInput() {
+  return usePart(sliderPrimitive, "input", {}, {}, "input");
+}
+var SliderControl = parts.Control;
+var SliderTrack = parts.Track;
+var SliderIndicator = parts.Indicator;
+function SliderThumb({
+  index = 0,
+  children,
+  "aria-label": label,
+  "aria-labelledby": labelledBy,
+  "aria-describedby": describedBy,
+  ...props
+}) {
+  const thumb = { index, id: String(index) };
+  const input = /* @__PURE__ */ jsx(
+    ThumbInput,
+    {
+      ...thumb,
+      "aria-label": label,
+      "aria-labelledby": labelledBy,
+      "aria-describedby": describedBy
+    }
+  );
+  return usePart(sliderPrimitive, "thumb", thumb, {
+    ...props,
+    children: withAfter(children, input)
+  });
+}
+function ThumbInput({
+  index,
+  id,
+  ...named
+}) {
+  const { field } = useSlider("SliderThumb");
+  const render = (input) => {
+    const { value, ...rest } = field ? field.props(input) : input;
+    return /* @__PURE__ */ jsx("input", { ...rest, defaultValue: value });
+  };
+  return usePart(
+    sliderPrimitive,
+    "thumb-input",
+    { index, id },
+    { ...named, render },
+    "input"
+  );
+}
+function SliderValue({
+  children = text,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(parts.Value, { ...props, children });
+}
+var text = (state) => state.text;
+export {
+  Slider,
+  SliderControl,
+  SliderIndicator,
+  SliderThumb,
+  SliderTrack,
+  SliderValue,
+  createSliderController
+};

package/dist/switch.d.ts

@@ -0,0 +1,15 @@
+import { type SwitchOptions, type SwitchState } from "@ui-sdk/core/switch";
+import { type ButtonControlProps } from "./field-context.js";
+/**
+ * A control that turns a setting on or off, with the hidden native input that takes part in the form.
+ * @stable
+ */
+declare function Switch({ disabled, name, render, ...props }: SwitchOptions & ButtonControlProps<SwitchState>): import("react").JSX.Element;
+/**
+ * The thumb that slides along the switch as it turns on or off.
+ * @stable
+ */
+declare const SwitchThumb: import("./use-primitive.js").PartComponent<import("@ui-sdk/core/switch").SwitchPrimitive, "thumb", "span">;
+export { createSwitchController } from "@ui-sdk/core/switch";
+export type { SwitchApi, SwitchCheckedChangeReason, SwitchController, SwitchOptions, SwitchPrimitive, SwitchState, SwitchThumbState, } from "@ui-sdk/core/switch";
+export { Switch, SwitchThumb };

package/dist/switch.js

@@ -0,0 +1,39 @@
+"use client";
+// src/switch.tsx
+import {
+  switchPrimitive
+} from "@ui-sdk/core/switch";
+import {
+  controlRender,
+  useFieldControl
+} from "./field-context.js";
+import { createParts, usePart } from "./use-primitive.js";
+import { createSwitchController } from "@ui-sdk/core/switch";
+import { jsx } from "react/jsx-runtime";
+var parts = createParts(switchPrimitive, { root: "button", thumb: "span" });
+function SwitchInput() {
+  return usePart(switchPrimitive, "input", {}, {}, "input");
+}
+function Switch({
+  disabled,
+  name,
+  render,
+  ...props
+}) {
+  const field = useFieldControl();
+  return /* @__PURE__ */ jsx(
+    parts.Root,
+    {
+      ...props,
+      disabled: disabled || field?.disabled,
+      name: name ?? field?.name,
+      render: controlRender(field, "button", render, /* @__PURE__ */ jsx(SwitchInput, {}))
+    }
+  );
+}
+var SwitchThumb = parts.Thumb;
+export {
+  Switch,
+  SwitchThumb,
+  createSwitchController
+};