@aaas-pro/library 0.0.0-stage → 0.1.0

package/dist/primitives/command.d.ts

@@ -0,0 +1,43 @@
+import * as React from 'react';
+import { type DivProps } from './core';
+type Filter = (value: string, search: string, keywords?: string[]) => number;
+export interface CommandProps extends Omit<DivProps, 'defaultValue'> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    shouldFilter?: boolean;
+    filter?: Filter;
+    loop?: boolean;
+    label?: string;
+}
+export declare function textOf(children: React.ReactNode): string;
+declare function Root({ value, defaultValue, onValueChange, shouldFilter, filter, loop, label, onKeyDown, ...props }: CommandProps): React.JSX.Element;
+declare function Input({ value, onValueChange, onChange, ...props }: Omit<React.ComponentProps<'input'>, 'value'> & {
+    value?: string;
+    onValueChange?: (value: string) => void;
+}): React.JSX.Element;
+declare function List(props: DivProps): React.JSX.Element;
+declare function Empty(props: DivProps): React.JSX.Element | null;
+declare function Group({ heading, forceMount, children, ...props }: DivProps & {
+    heading?: React.ReactNode;
+    forceMount?: boolean;
+}): React.JSX.Element;
+declare function Item({ value, keywords, disabled, onSelect, children, forceMount, onClick, onPointerMove, ...props }: Omit<DivProps, 'onSelect'> & {
+    value?: string;
+    keywords?: string[];
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    forceMount?: boolean;
+}): React.JSX.Element;
+declare function Separator({ alwaysRender: _always, ...props }: DivProps & {
+    alwaysRender?: boolean;
+}): React.JSX.Element;
+export declare const Command: typeof Root & {
+    Input: typeof Input;
+    List: typeof List;
+    Empty: typeof Empty;
+    Group: typeof Group;
+    Item: typeof Item;
+    Separator: typeof Separator;
+};
+export {};

package/dist/primitives/command.js

@@ -0,0 +1,98 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { useControllable, DivPart } from "./core.js";
+const defaultFilter = (value, query, keywords = []) => `${value} ${keywords.join(" ")}`.toLocaleLowerCase().includes(query.toLocaleLowerCase().trim()) ? 1 : 0;
+const Context = React.createContext({ query: "", setQuery: (_query) => {
+}, value: "", setValue: (_value) => {
+}, shouldFilter: true, filter: defaultFilter, items: /* @__PURE__ */ new Map(), register: (_item) => () => {
+}, listId: "" });
+const GroupContext = React.createContext("");
+function textOf(children) {
+  return React.Children.toArray(children).map((child) => typeof child === "string" || typeof child === "number" ? String(child) : React.isValidElement(child) ? textOf(child.props.children) : "").join(" ");
+}
+function Root({ value, defaultValue = "", onValueChange, shouldFilter = true, filter = defaultFilter, loop = false, label = "命令", onKeyDown, ...props }) {
+  const [query, setQuery] = React.useState(""), [current, setValue] = useControllable(value, defaultValue, onValueChange), [items, setItems] = React.useState(/* @__PURE__ */ new Map());
+  const listId = React.useId();
+  const register = React.useCallback((item) => {
+    setItems((previous) => new Map(previous).set(item.id, item));
+    return () => setItems((previous) => {
+      const next = new Map(previous);
+      next.delete(item.id);
+      return next;
+    });
+  }, []);
+  return /* @__PURE__ */ jsx(Context.Provider, { value: { query, setQuery, value: current, setValue, shouldFilter, filter, items, register, listId }, children: /* @__PURE__ */ jsx(DivPart, { ...props, "aria-label": label, "data-command-root": "", onKeyDown: (event) => {
+    onKeyDown?.(event);
+    if (event.defaultPrevented)
+      return;
+    const candidates = [...items.values()].filter((item) => !item.disabled && (!shouldFilter || filter(`${item.value} ${item.text}`, query, item.keywords) > 0));
+    if (["ArrowDown", "ArrowUp", "Home", "End"].includes(event.key) && candidates.length) {
+      event.preventDefault();
+      const index = candidates.findIndex((item) => item.value === current);
+      let next = event.key === "Home" ? 0 : event.key === "End" ? candidates.length - 1 : index + (event.key === "ArrowDown" ? 1 : -1);
+      next = loop ? (next + candidates.length) % candidates.length : Math.max(0, Math.min(candidates.length - 1, next));
+      setValue(candidates[next].value);
+      document.getElementById(candidates[next].id)?.scrollIntoView?.({ block: "nearest" });
+    } else if (event.key === "Enter") {
+      const item = candidates.find((item2) => item2.value === current) ?? candidates[0];
+      if (item) {
+        event.preventDefault();
+        document.getElementById(item.id)?.click();
+      }
+    }
+  } }) });
+}
+function Input({ value, onValueChange, onChange, ...props }) {
+  const state = React.useContext(Context), current = value ?? state.query, active = [...state.items.values()].find((item) => item.value === state.value);
+  React.useEffect(() => {
+    if (value !== void 0)
+      state.setQuery(value);
+  }, [value]);
+  return /* @__PURE__ */ jsx("input", { ...props, "data-command-input": "", role: "combobox", "aria-expanded": "true", "aria-controls": state.listId, "aria-autocomplete": "list", "aria-activedescendant": active?.id, value: current, onChange: (event) => {
+    onChange?.(event);
+    if (!event.defaultPrevented) {
+      state.setQuery(event.target.value);
+      onValueChange?.(event.target.value);
+    }
+  } });
+}
+function List(props) {
+  const state = React.useContext(Context);
+  return /* @__PURE__ */ jsx(DivPart, { ...props, id: state.listId, "data-command-list": "", role: "listbox" });
+}
+function Empty(props) {
+  const state = React.useContext(Context);
+  return [...state.items.values()].some((item) => !state.shouldFilter || state.filter(`${item.value} ${item.text}`, state.query, item.keywords) > 0) ? null : /* @__PURE__ */ jsx(DivPart, { ...props, role: "status" });
+}
+function Group({ heading, forceMount, children, ...props }) {
+  const state = React.useContext(Context), id = React.useId();
+  const candidates = [...state.items.values()].filter((item) => item.group === id), empty = candidates.length > 0 && !candidates.some((item) => !state.shouldFilter || state.filter(`${item.value} ${item.text}`, state.query, item.keywords) > 0);
+  return /* @__PURE__ */ jsx(GroupContext.Provider, { value: id, children: /* @__PURE__ */ jsxs(DivPart, { ...props, "data-command-group": "", role: "group", "aria-labelledby": heading ? `${id}-heading` : void 0, hidden: !forceMount && empty, children: [
+    heading && /* @__PURE__ */ jsx("div", { id: `${id}-heading`, "data-command-group-heading": "", children: heading }),
+    children
+  ] }) });
+}
+function Item({ value, keywords = [], disabled = false, onSelect, children, forceMount = false, onClick, onPointerMove, ...props }) {
+  const state = React.useContext(Context), group = React.useContext(GroupContext), id = React.useId(), text = textOf(children), key = value ?? text, keywordKey = keywords.join("\0");
+  React.useEffect(() => state.register({ id, value: key, text, keywords, disabled, group }), [id, key, text, keywordKey, disabled, group, state.register]);
+  const shown = forceMount || !state.shouldFilter || state.filter(`${key} ${text}`, state.query, keywords) > 0;
+  return /* @__PURE__ */ jsx(DivPart, { ...props, id, role: "option", tabIndex: -1, hidden: !shown, "data-command-item": "", "data-selected": state.value === key, "data-disabled": disabled, "aria-selected": state.value === key, "aria-disabled": disabled, onPointerMove: (event) => {
+    onPointerMove?.(event);
+    if (!disabled)
+      state.setValue(key);
+  }, onClick: (event) => {
+    onClick?.(event);
+    if (!event.defaultPrevented && !disabled) {
+      state.setValue(key);
+      onSelect?.(key);
+    }
+  }, children });
+}
+function Separator({ alwaysRender: _always, ...props }) {
+  return /* @__PURE__ */ jsx(DivPart, { ...props, role: "separator" });
+}
+const Command = Object.assign(Root, { Input, List, Empty, Group, Item, Separator });
+export {
+  Command,
+  textOf
+};

package/dist/primitives/context-menu.d.ts

@@ -0,0 +1,24 @@
+export declare const Root: (props: import("./layer").ModalRootProps) => React.ReactElement, Trigger: ({ onContextMenu, ref, disabled, ...props }: import("./core").ButtonProps) => import("react").JSX.Element, Portal: ({ children, container, forceMount }: import("./layer").PortalProps) => import("react").ReactPortal | null, Content: ({ onKeyDown, loop, ...props }: import("./layer").LayerContentProps & {
+    loop?: boolean;
+}) => import("react").JSX.Element, Group: (props: import("./core").DivProps) => import("react").JSX.Element, Label: (props: import("./core").DivProps) => import("react").JSX.Element, Item: ({ onSelect, textValue: _text, onClick, onPointerMove, ...props }: Omit<import("./core").ButtonProps, "onSelect"> & {
+    onSelect?: (event: Event) => void;
+    textValue?: string;
+}) => import("react").JSX.Element, CheckboxItem: ({ checked, defaultChecked, onCheckedChange, children, onSelect, ...props }: (Omit<import("./core").ButtonProps, "onSelect"> & {
+    onSelect?: (event: Event) => void;
+    textValue?: string;
+}) & {
+    checked?: boolean | "indeterminate";
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+}) => import("react").JSX.Element, RadioGroup: ({ value, defaultValue, onValueChange, ...props }: Omit<import("./core").DivProps, "defaultValue"> & {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+}) => import("react").JSX.Element, RadioItem: ({ value, children, onSelect, ...props }: (Omit<import("./core").ButtonProps, "onSelect"> & {
+    onSelect?: (event: Event) => void;
+    textValue?: string;
+}) & {
+    value: string;
+}) => import("react").JSX.Element, Separator: (props: import("./core").DivProps) => import("react").JSX.Element, ItemIndicator: ({ forceMount, ...props }: React.ComponentProps<"span"> & {
+    forceMount?: true;
+}) => import("react").JSX.Element | null, Sub: (props: import("./layer").ModalRootProps) => React.ReactElement, SubTrigger: ({ onClick, onPointerEnter, onKeyDown, ref, ...props }: import("./core").ButtonProps) => import("react").JSX.Element, SubContent: ({ onKeyDown, ...props }: import("./layer").LayerContentProps) => import("react").JSX.Element;

package/dist/primitives/context-menu.js

@@ -0,0 +1,19 @@
+import { createMenu } from "./menu.js";
+const { Root, Trigger, Portal, Content, Group, Label, Item, CheckboxItem, RadioGroup, RadioItem, Separator, ItemIndicator, Sub, SubTrigger, SubContent } = createMenu(true);
+export {
+  CheckboxItem,
+  Content,
+  Group,
+  Item,
+  ItemIndicator,
+  Label,
+  Portal,
+  RadioGroup,
+  RadioItem,
+  Root,
+  Separator,
+  Sub,
+  SubContent,
+  SubTrigger,
+  Trigger
+};

package/dist/primitives/core.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+export declare function setRef<T>(ref: React.Ref<T> | undefined, value: T | null): void;
+export declare function useMergedRef<T>(...refs: (React.Ref<T> | undefined)[]): (value: T | null) => void;
+export declare function useControllable<T>(value: T | undefined, defaultValue: T, onChange?: (next: T) => void): readonly [T, (next: T | ((previous: T) => T)) => void];
+/** Compose a single child without adding a DOM wrapper. Child handlers run first. */
+export declare function Slot({ children, ref, ...props }: React.HTMLAttributes<HTMLElement> & {
+    children?: React.ReactNode;
+    ref?: React.Ref<HTMLElement>;
+}): React.ReactElement<Record<string, unknown>, string | React.JSXElementConstructor<any>>;
+export type ButtonProps = React.ComponentProps<'button'> & {
+    asChild?: boolean;
+};
+export declare function ButtonPart({ asChild, ...props }: ButtonProps): React.JSX.Element;
+export type DivProps = React.ComponentProps<'div'> & {
+    asChild?: boolean;
+};
+export declare function DivPart({ asChild, ...props }: DivProps): React.JSX.Element;
+export declare function focusable(container: HTMLElement): HTMLElement[];
+/** Roving keyboard navigation, disabled controls are skipped. */
+export declare function moveFocus(event: React.KeyboardEvent<HTMLElement>, selector: string, { vertical, loop, select }?: {
+    vertical?: boolean;
+    loop?: boolean;
+    select?: boolean;
+}): void;
+export declare function selectionEvent(callback?: (event: Event) => void): boolean;

package/dist/primitives/core.js

@@ -0,0 +1,89 @@
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+function setRef(ref, value) {
+  if (typeof ref === "function")
+    ref(value);
+  else if (ref)
+    ref.current = value;
+}
+function useMergedRef(...refs) {
+  return React.useMemo(() => (value) => refs.forEach((ref) => setRef(ref, value)), refs);
+}
+function useControllable(value, defaultValue, onChange) {
+  const [local, setLocal] = React.useState(defaultValue);
+  const current = value === void 0 ? local : value;
+  const latest = React.useRef({ current, value, onChange });
+  latest.current = { current, value, onChange };
+  const set = React.useCallback((next) => {
+    const previous = latest.current;
+    const resolved = typeof next === "function" ? next(previous.current) : next;
+    if (Object.is(resolved, previous.current))
+      return;
+    if (previous.value === void 0)
+      setLocal(resolved);
+    previous.onChange?.(resolved);
+  }, []);
+  return [current, set];
+}
+function Slot({ children, ref, ...props }) {
+  if (!React.isValidElement(children))
+    throw new Error("asChild requires one React element");
+  const child = children;
+  const merged = { ...props, ...child.props };
+  for (const [key, parent] of Object.entries(props)) {
+    const own = child.props[key];
+    if (/^on[A-Z]/.test(key) && typeof parent === "function") {
+      merged[key] = (...args) => {
+        if (typeof own === "function")
+          own(...args);
+        if (!args[0]?.defaultPrevented)
+          parent(...args);
+      };
+    }
+  }
+  merged.className = [props.className, child.props.className].filter(Boolean).join(" ");
+  merged.style = { ...props.style, ...child.props.style };
+  const combined = useMergedRef(ref, child.props.ref);
+  return React.cloneElement(child, { ...merged, ref: combined });
+}
+function ButtonPart({ asChild, ...props }) {
+  return asChild ? /* @__PURE__ */ jsx(Slot, { ...props, ref: props.ref, children: props.children }) : /* @__PURE__ */ jsx("button", { type: "button", ...props });
+}
+function DivPart({ asChild, ...props }) {
+  return asChild ? /* @__PURE__ */ jsx(Slot, { ...props, children: props.children }) : /* @__PURE__ */ jsx("div", { ...props });
+}
+function focusable(container) {
+  return [...container.querySelectorAll('button:not(:disabled),a[href],input:not(:disabled),select:not(:disabled),textarea:not(:disabled),[tabindex]:not([tabindex="-1"])')].filter((node) => node.tabIndex >= 0 && !node.hidden && !node.closest('[hidden],[inert],[aria-hidden="true"]') && getComputedStyle(node).display !== "none");
+}
+function moveFocus(event, selector, { vertical = false, loop = true, select = false } = {}) {
+  const rtl = !vertical && (event.currentTarget.closest("[dir]")?.getAttribute("dir") === "rtl" || getComputedStyle(event.currentTarget).direction === "rtl");
+  const nextKey = vertical ? "ArrowDown" : rtl ? "ArrowLeft" : "ArrowRight", prevKey = vertical ? "ArrowUp" : rtl ? "ArrowRight" : "ArrowLeft";
+  if (![nextKey, prevKey, "Home", "End"].includes(event.key))
+    return;
+  const nodes = [...event.currentTarget.querySelectorAll(selector)].filter((n) => !n.matches(':disabled,[aria-disabled="true"]') && !n.closest("[hidden]"));
+  if (!nodes.length)
+    return;
+  const index = nodes.indexOf(document.activeElement);
+  let next = event.key === "Home" ? 0 : event.key === "End" ? nodes.length - 1 : index + (event.key === nextKey ? 1 : -1);
+  next = loop ? (next + nodes.length) % nodes.length : Math.max(0, Math.min(nodes.length - 1, next));
+  event.preventDefault();
+  nodes[next].focus();
+  if (select)
+    nodes[next].click();
+}
+function selectionEvent(callback) {
+  const event = new Event("select", { cancelable: true });
+  callback?.(event);
+  return event.defaultPrevented;
+}
+export {
+  ButtonPart,
+  DivPart,
+  Slot,
+  focusable,
+  moveFocus,
+  selectionEvent,
+  setRef,
+  useControllable,
+  useMergedRef
+};

package/dist/primitives/dialog.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { type ModalRootProps, type ModalContentProps } from './layer';
+export declare const Trigger: ({ onClick, onKeyDown, onPointerEnter, onPointerLeave, onFocus, onBlur, onContextMenu, ref, disabled, ...props }: import("./core").ButtonProps) => React.JSX.Element, Close: ({ onClick, ...props }: import("./core").ButtonProps) => React.JSX.Element, Portal: ({ children, container, forceMount }: import("./layer").PortalProps) => React.ReactPortal | null, Overlay: ({ forceMount, ...props }: import("./core").DivProps & {
+    forceMount?: true;
+}) => React.JSX.Element | null, Title: (props: React.ComponentProps<"h2">) => React.JSX.Element, Description: (props: React.ComponentProps<"p">) => React.JSX.Element;
+export declare const Root: (props: ModalRootProps) => React.ReactElement;
+export declare const Content: (props: ModalContentProps) => React.ReactElement | null;

package/dist/primitives/dialog.js

@@ -0,0 +1,15 @@
+import { createLayer } from "./layer.js";
+const family = createLayer({ modal: true, floating: false });
+const { Trigger, Close, Portal, Overlay, Title, Description } = family;
+const Root = family.Root;
+const Content = family.Content;
+export {
+  Close,
+  Content,
+  Description,
+  Overlay,
+  Portal,
+  Root,
+  Title,
+  Trigger
+};

package/dist/primitives/drawer.d.ts

@@ -0,0 +1,30 @@
+import * as React from 'react';
+import { type ModalRootProps, type ModalContentProps } from './layer';
+type Direction = 'top' | 'right' | 'bottom' | 'left';
+interface DrawerProps extends ModalRootProps {
+    direction?: Direction;
+    dismissible?: boolean;
+}
+declare function Root({ direction, dismissible, children, ...props }: DrawerProps): React.JSX.Element;
+declare function Content({ onPointerDown, onPointerUp, onPointerDownOutside, onEscapeKeyDown, ...props }: ModalContentProps): React.JSX.Element;
+export declare const Drawer: {
+    Root: typeof Root;
+    Content: typeof Content;
+    Provider: ({ children, delayDuration }: {
+        children?: React.ReactNode;
+        delayDuration?: number;
+    }) => React.JSX.Element;
+    Trigger: ({ onClick, onKeyDown, onPointerEnter, onPointerLeave, onFocus, onBlur, onContextMenu, ref, disabled, ...props }: import("./core").ButtonProps) => React.JSX.Element;
+    Anchor: ({ ref, ...props }: import("./core").DivProps) => React.JSX.Element;
+    Close: ({ onClick, ...props }: import("./core").ButtonProps) => React.JSX.Element;
+    Portal: ({ children, container, forceMount }: import("./layer").PortalProps) => React.ReactPortal | null;
+    Overlay: ({ forceMount, ...props }: import("./core").DivProps & {
+        forceMount?: true;
+    }) => React.JSX.Element | null;
+    Title: (props: React.ComponentProps<"h2">) => React.JSX.Element;
+    Description: (props: React.ComponentProps<"p">) => React.JSX.Element;
+    Arrow: (props: React.ComponentProps<"span">) => React.JSX.Element;
+    Sub: (props: import("./layer").LayerRootProps) => React.JSX.Element;
+    useLayer: () => import("./layer").LayerState;
+};
+export {};

package/dist/primitives/drawer.js

@@ -0,0 +1,39 @@
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { createLayer } from "./layer.js";
+const family = createLayer({ modal: true, floating: false });
+const Context = React.createContext({ direction: "bottom", dismissible: true });
+function Root({ direction = "bottom", dismissible = true, children, ...props }) {
+  return /* @__PURE__ */ jsx(family.Root, { ...props, direction, children: /* @__PURE__ */ jsx(Context.Provider, { value: { direction, dismissible }, children }) });
+}
+function Content({ onPointerDown, onPointerUp, onPointerDownOutside, onEscapeKeyDown, ...props }) {
+  const { direction, dismissible } = React.useContext(Context), state = family.useLayer();
+  const start = React.useRef(null);
+  return /* @__PURE__ */ jsx(family.Content, { ...props, "data-drawer-direction": direction, onPointerDownOutside: (event) => {
+    onPointerDownOutside?.(event);
+    if (!dismissible)
+      event.preventDefault();
+  }, onEscapeKeyDown: (event) => {
+    onEscapeKeyDown?.(event);
+    if (!dismissible)
+      event.preventDefault();
+  }, onPointerDown: (event) => {
+    onPointerDown?.(event);
+    if (event.target.closest("[data-drawer-handle]")) {
+      start.current = { x: event.clientX, y: event.clientY };
+      event.currentTarget.setPointerCapture?.(event.pointerId);
+    }
+  }, onPointerUp: (event) => {
+    onPointerUp?.(event);
+    if (!start.current)
+      return;
+    const delta = direction === "bottom" ? event.clientY - start.current.y : direction === "top" ? start.current.y - event.clientY : direction === "right" ? event.clientX - start.current.x : start.current.x - event.clientX;
+    start.current = null;
+    if (dismissible && delta > 60)
+      state.setOpen(false);
+  } });
+}
+const Drawer = { ...family, Root, Content };
+export {
+  Drawer
+};

package/dist/primitives/dropdown-menu.d.ts

@@ -0,0 +1,24 @@
+export declare const Root: (props: import("./layer").ModalRootProps) => React.ReactElement, Trigger: ({ onContextMenu, ref, disabled, ...props }: import("./core").ButtonProps) => import("react").JSX.Element, Portal: ({ children, container, forceMount }: import("./layer").PortalProps) => import("react").ReactPortal | null, Content: ({ onKeyDown, loop, ...props }: import("./layer").LayerContentProps & {
+    loop?: boolean;
+}) => import("react").JSX.Element, Group: (props: import("./core").DivProps) => import("react").JSX.Element, Label: (props: import("./core").DivProps) => import("react").JSX.Element, Item: ({ onSelect, textValue: _text, onClick, onPointerMove, ...props }: Omit<import("./core").ButtonProps, "onSelect"> & {
+    onSelect?: (event: Event) => void;
+    textValue?: string;
+}) => import("react").JSX.Element, CheckboxItem: ({ checked, defaultChecked, onCheckedChange, children, onSelect, ...props }: (Omit<import("./core").ButtonProps, "onSelect"> & {
+    onSelect?: (event: Event) => void;
+    textValue?: string;
+}) & {
+    checked?: boolean | "indeterminate";
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+}) => import("react").JSX.Element, RadioGroup: ({ value, defaultValue, onValueChange, ...props }: Omit<import("./core").DivProps, "defaultValue"> & {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+}) => import("react").JSX.Element, RadioItem: ({ value, children, onSelect, ...props }: (Omit<import("./core").ButtonProps, "onSelect"> & {
+    onSelect?: (event: Event) => void;
+    textValue?: string;
+}) & {
+    value: string;
+}) => import("react").JSX.Element, Separator: (props: import("./core").DivProps) => import("react").JSX.Element, ItemIndicator: ({ forceMount, ...props }: React.ComponentProps<"span"> & {
+    forceMount?: true;
+}) => import("react").JSX.Element | null, Sub: (props: import("./layer").ModalRootProps) => React.ReactElement, SubTrigger: ({ onClick, onPointerEnter, onKeyDown, ref, ...props }: import("./core").ButtonProps) => import("react").JSX.Element, SubContent: ({ onKeyDown, ...props }: import("./layer").LayerContentProps) => import("react").JSX.Element;

package/dist/primitives/dropdown-menu.js

@@ -0,0 +1,19 @@
+import { createMenu } from "./menu.js";
+const { Root, Trigger, Portal, Content, Group, Label, Item, CheckboxItem, RadioGroup, RadioItem, Separator, ItemIndicator, Sub, SubTrigger, SubContent } = createMenu();
+export {
+  CheckboxItem,
+  Content,
+  Group,
+  Item,
+  ItemIndicator,
+  Label,
+  Portal,
+  RadioGroup,
+  RadioItem,
+  Root,
+  Separator,
+  Sub,
+  SubContent,
+  SubTrigger,
+  Trigger
+};

package/dist/primitives/form.d.ts

@@ -0,0 +1,154 @@
+import * as React from 'react';
+export type FieldValues = Record<string, any>;
+export type FieldPath<T extends FieldValues> = Extract<keyof T, string>;
+export interface FieldError {
+    type: string;
+    message: string;
+}
+export interface ValidationRules<V = unknown> {
+    required?: boolean | string;
+    min?: number | {
+        value: number;
+        message: string;
+    };
+    max?: number | {
+        value: number;
+        message: string;
+    };
+    minLength?: number | {
+        value: number;
+        message: string;
+    };
+    maxLength?: number | {
+        value: number;
+        message: string;
+    };
+    pattern?: RegExp | {
+        value: RegExp;
+        message: string;
+    };
+    validate?: (value: V) => boolean | string | Promise<boolean | string>;
+}
+interface FormSnapshot<T> {
+    values: T;
+    errors: Partial<Record<keyof T, FieldError>>;
+    touchedFields: Partial<Record<keyof T, boolean>>;
+    dirtyFields: Partial<Record<keyof T, boolean>>;
+    isSubmitting: boolean;
+    isSubmitted: boolean;
+}
+export interface FormControl<T extends FieldValues> {
+    snapshot: FormSnapshot<T>;
+    subscribe: (callback: () => void) => () => void;
+    rules: Map<string, ValidationRules<any>>;
+    refs: Map<string, HTMLElement>;
+    setValue: <K extends FieldPath<T>>(name: K, value: T[K], options?: {
+        shouldValidate?: boolean;
+        shouldTouch?: boolean;
+        shouldDirty?: boolean;
+    }) => void;
+    touch: (name: FieldPath<T>) => void;
+    validate: (names?: FieldPath<T>[]) => Promise<boolean>;
+}
+export interface UseFormOptions<T extends FieldValues> {
+    defaultValues?: Partial<T>;
+    mode?: 'onSubmit' | 'onChange' | 'onBlur';
+}
+export declare function useForm<T extends FieldValues = FieldValues>({ defaultValues, mode }?: UseFormOptions<T>): {
+    control: FormControl<T>;
+    formState: {
+        isDirty: boolean;
+        isValid: boolean;
+        values: T;
+        errors: Partial<Record<keyof T, FieldError>>;
+        touchedFields: Partial<Record<keyof T, boolean>>;
+        dirtyFields: Partial<Record<keyof T, boolean>>;
+        isSubmitting: boolean;
+        isSubmitted: boolean;
+    };
+    getFieldState: (name: FieldPath<T>, state?: FormSnapshot<T>) => {
+        error: Partial<Record<keyof T, FieldError>>[Extract<keyof T, string>];
+        invalid: boolean;
+        isTouched: boolean;
+        isDirty: boolean;
+    };
+    getValues: () => T;
+    setValue: <K extends Extract<keyof T, string>>(name: K, value: T[K], options?: {
+        shouldValidate?: boolean;
+        shouldTouch?: boolean;
+        shouldDirty?: boolean;
+    }) => void;
+    trigger: (name?: FieldPath<T>) => Promise<boolean>;
+    reset(values?: Partial<T>): void;
+    setFocus(name: FieldPath<T>): void;
+    handleSubmit(onValid: (values: T) => unknown | Promise<unknown>, onInvalid?: (errors: FormSnapshot<T>["errors"]) => unknown): (event?: React.FormEvent) => Promise<void>;
+};
+export type UseFormReturn<T extends FieldValues> = ReturnType<typeof useForm<T>>;
+export declare function FormProvider<T extends FieldValues>({ children, ...form }: UseFormReturn<T> & {
+    children?: React.ReactNode;
+}): React.JSX.Element;
+export declare function useFormContext(): {
+    control: FormControl<FieldValues>;
+    formState: {
+        isDirty: boolean;
+        isValid: boolean;
+        values: FieldValues;
+        errors: Partial<Record<string, FieldError>>;
+        touchedFields: Partial<Record<string, boolean>>;
+        dirtyFields: Partial<Record<string, boolean>>;
+        isSubmitting: boolean;
+        isSubmitted: boolean;
+    };
+    getFieldState: (name: string, state?: FormSnapshot<FieldValues>) => {
+        error: FieldError | undefined;
+        invalid: boolean;
+        isTouched: boolean;
+        isDirty: boolean;
+    };
+    getValues: () => FieldValues;
+    setValue: <K extends string>(name: K, value: any, options?: {
+        shouldValidate?: boolean;
+        shouldTouch?: boolean;
+        shouldDirty?: boolean;
+    }) => void;
+    trigger: (name?: string | undefined) => Promise<boolean>;
+    reset(values?: Partial<FieldValues>): void;
+    setFocus(name: string): void;
+    handleSubmit(onValid: (values: FieldValues) => unknown | Promise<unknown>, onInvalid?: ((errors: Partial<Record<string, FieldError>>) => unknown) | undefined): (event?: React.FormEvent) => Promise<void>;
+};
+export declare function useFormState(_options?: {
+    name?: string;
+}): {
+    isDirty: boolean;
+    isValid: boolean;
+    values: FieldValues;
+    errors: Partial<Record<string, FieldError>>;
+    touchedFields: Partial<Record<string, boolean>>;
+    dirtyFields: Partial<Record<string, boolean>>;
+    isSubmitting: boolean;
+    isSubmitted: boolean;
+};
+export interface ControllerProps<T extends FieldValues = FieldValues, K extends FieldPath<T> = FieldPath<T>> {
+    name: K;
+    control: FormControl<T>;
+    rules?: ValidationRules<T[K]>;
+    defaultValue?: T[K];
+    disabled?: boolean;
+    render: (props: {
+        field: {
+            name: K;
+            value: T[K];
+            onChange: (event: any) => void;
+            onBlur: () => void;
+            ref: (element: HTMLElement | null) => void;
+            disabled?: boolean;
+        };
+        fieldState: {
+            error?: FieldError;
+            invalid: boolean;
+        };
+        formState: FormSnapshot<T>;
+    }) => React.ReactElement;
+}
+export declare function Controller<T extends FieldValues, K extends FieldPath<T>>({ name, control, rules, defaultValue, disabled, render }: ControllerProps<T, K>): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+export {};