@cognite/aura 0.1.0

package/dist/components/ui/core/button-group/button-group.js

@@ -0,0 +1,83 @@
+import { jsx as a } from "react/jsx-runtime";
+import { mergeProps as i } from "@base-ui/react/merge-props";
+import { useRender as s } from "@base-ui/react/use-render";
+import { cva as l } from "class-variance-authority";
+import { cn as e } from "../../../../lib/utils.js";
+import { Separator as d } from "../separator/separator.js";
+const u = l(
+  "flex w-fit items-stretch [&>*]:focus-visible:z-10 [&>*]:focus-visible:relative [&>[data-slot=select-trigger]:not([class*='w-'])]:w-fit [&>input]:flex-1 has-[select[aria-hidden=true]:last-child]:[&>[data-slot=select-trigger]:last-of-type]:rounded-r-md has-[>[data-slot=button-group]]:gap-2",
+  {
+    variants: {
+      orientation: {
+        horizontal: "[&>*:not(:first-child)]:rounded-l-none [&>*:not(:first-child)]:border-l-0 [&>*:not(:last-child)]:rounded-r-none",
+        vertical: "flex-col [&>*:not(:first-child)]:rounded-t-none [&>*:not(:first-child)]:border-t-0 [&>*:not(:last-child)]:rounded-b-none"
+      }
+    },
+    defaultVariants: {
+      orientation: "horizontal"
+    }
+  }
+);
+function v({
+  className: o,
+  orientation: t,
+  ...r
+}) {
+  return /* @__PURE__ */ a(
+    "div",
+    {
+      role: "group",
+      "data-slot": "button-group",
+      "data-orientation": t,
+      className: e(u({ orientation: t }), o),
+      ...r
+    }
+  );
+}
+function b({
+  className: o,
+  render: t,
+  children: r,
+  ...n
+}) {
+  return s({
+    defaultTagName: "div",
+    props: i(
+      {
+        className: e(
+          "bg-muted flex items-center gap-2 rounded-md border px-4 text-sm font-medium shadow-xs [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4",
+          o
+        )
+      },
+      { ...n, children: r }
+    ),
+    render: t,
+    state: {
+      slot: "button-group-text"
+    }
+  });
+}
+function x({
+  className: o,
+  orientation: t = "vertical",
+  ...r
+}) {
+  return /* @__PURE__ */ a(
+    d,
+    {
+      "data-slot": "button-group-separator",
+      orientation: t,
+      className: e(
+        "bg-input relative m-0 self-stretch data-[orientation=vertical]:h-auto",
+        o
+      ),
+      ...r
+    }
+  );
+}
+export {
+  v as ButtonGroup,
+  x as ButtonGroupSeparator,
+  b as ButtonGroupText,
+  u as buttonGroupVariants
+};

package/dist/components/ui/core/button-group/button-group.metadata.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../../../lib/types';
+export declare const ButtonGroupMetadata: ComponentMeta;

package/dist/components/ui/core/button-group/button-group.metadata.js

@@ -0,0 +1,8 @@
+const o = {
+  name: "ButtonGroup",
+  status: "in-progress-code-review",
+  description: "A component for grouping buttons with horizontal or vertical orientation."
+};
+export {
+  o as ButtonGroupMetadata
+};

package/dist/components/ui/core/code-block/code-block.d.ts

@@ -0,0 +1,21 @@
+import { ComponentProps, HTMLAttributes } from 'react';
+import { BundledLanguage } from 'shiki';
+import { Button } from '../button/button';
+declare const CodeBlock: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    code: string;
+    copyText?: string;
+    collapsed?: boolean;
+    language: BundledLanguage;
+    showLineNumbers?: boolean;
+} & import('react').RefAttributes<HTMLDivElement>>;
+type CodeBlockCopyButtonProps = ComponentProps<typeof Button> & {
+    onCopy?: () => void;
+    onError?: (error: Error) => void;
+    timeout?: number;
+};
+declare const CodeBlockCopyButton: import('react').ForwardRefExoticComponent<Omit<CodeBlockCopyButtonProps, "ref"> & import('react').RefAttributes<HTMLElement>>;
+declare const CodeBlockCollapseButton: import('react').ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ButtonProps & import('class-variance-authority').VariantProps<(props?: ({
+    variant?: "default" | "destructive" | "secondary" | "outline" | "ghost" | "link" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string>, "ref"> & import('react').RefAttributes<HTMLElement>, "ref"> & import('react').RefAttributes<HTMLElement>>;
+export { CodeBlock, CodeBlockCollapseButton, CodeBlockCopyButton };

package/dist/components/ui/core/code-block/code-block.js

@@ -0,0 +1,146 @@
+import { jsx as o, jsxs as z } from "react/jsx-runtime";
+import { createContext as E, forwardRef as y, useState as C, useMemo as T, useEffect as M, useContext as N } from "react";
+import { IconCheck as j, IconCopy as P, IconSelector as $ } from "@tabler/icons-react";
+import { isStorybookTestEnv as f, highlightCode as A, cn as d } from "../../../../lib/utils.js";
+import { Button as _ } from "../button/button.js";
+const g = E({
+  code: "",
+  copyText: "",
+  isCollapsed: !1,
+  setIsCollapsed: () => {
+  },
+  lineCount: 0
+}), D = y(
+  ({
+    code: e,
+    copyText: t,
+    language: r,
+    showLineNumbers: l = !1,
+    collapsed: s = !1,
+    className: c,
+    children: n,
+    ...h
+  }, p) => {
+    const [k, m] = C(""), [b, a] = C(""), [i, H] = C(s), w = e.split(`
+`).length, B = t ?? e, I = T(
+      () => f ? `<pre><code>${e}</code></pre>` : "",
+      [e]
+    );
+    M(() => {
+      if (f) return;
+      let v = !1;
+      return A(e, r, l).then(([x, u]) => {
+        v || (m(x), a(u));
+      }).catch((x) => {
+        if (console.error("Failed to highlight code:", x), !v) {
+          const u = `<pre><code>${e}</code></pre>`;
+          m(u), a(u);
+        }
+      }), () => {
+        v = !0;
+      };
+    }, [e, r, l]);
+    const S = T(
+      () => ({
+        code: e,
+        copyText: B,
+        isCollapsed: i,
+        setIsCollapsed: H,
+        lineCount: w
+      }),
+      [e, B, i, w]
+    );
+    return /* @__PURE__ */ o(g.Provider, { value: S, children: /* @__PURE__ */ o(
+      "div",
+      {
+        ref: p,
+        "data-slot": "code-block",
+        className: d(
+          "group/code-block relative w-full overflow-hidden rounded-md bg-background text-foreground",
+          c
+        ),
+        ...h,
+        children: /* @__PURE__ */ z("div", { className: "relative", children: [
+          /* @__PURE__ */ o(
+            "div",
+            {
+              className: d(
+                "dark:hidden [&>pre]:m-0 [&>pre]:bg-card [&>pre]:p-4 [&>pre]:text-foreground [&>pre]:text-sm [&_code]:font-mono [&_code]:text-sm [&>pre]:overflow-x-auto",
+                i && "max-h-26 overflow-y-hidden"
+              ),
+              dangerouslySetInnerHTML: {
+                __html: f ? I : k
+              }
+            }
+          ),
+          /* @__PURE__ */ o(
+            "div",
+            {
+              className: d(
+                "hidden dark:block [&>pre]:m-0 [&>pre]:bg-card [&>pre]:p-4 [&>pre]:text-foreground [&>pre]:text-sm [&_code]:font-mono [&_code]:text-sm [&>pre]:overflow-x-auto",
+                i && "max-h-26 overflow-y-hidden"
+              ),
+              dangerouslySetInnerHTML: {
+                __html: f ? I : b
+              }
+            }
+          ),
+          i && /* @__PURE__ */ o("div", { className: "pointer-events-none absolute bottom-0 left-0 right-0 h-3/4 bg-linear-to-b from-transparent via-card/70 to-card" }),
+          n && /* @__PURE__ */ o("div", { className: "absolute top-2 right-2 hidden items-center gap-2 group-hover/code-block:flex", children: n })
+        ] })
+      }
+    ) });
+  }
+);
+D.displayName = "CodeBlock";
+const F = y(({ onCopy: e, onError: t, timeout: r = 2e3, children: l, className: s, ...c }, n) => {
+  const [h, p] = C(!1), { copyText: k } = N(g), m = async () => {
+    if (typeof window > "u" || !navigator?.clipboard?.writeText) {
+      t?.(new Error("Clipboard API not available"));
+      return;
+    }
+    try {
+      await navigator.clipboard.writeText(k), p(!0), e?.(), setTimeout(() => p(!1), r);
+    } catch (a) {
+      console.warn("Clipboard write failed:", a), t?.(
+        a instanceof Error ? a : new Error("Clipboard write failed")
+      );
+    }
+  }, b = h ? j : P;
+  return /* @__PURE__ */ o(
+    _,
+    {
+      ref: n,
+      "data-slot": "code-block-copy-button",
+      className: d("shrink-0", s),
+      onClick: m,
+      size: "icon",
+      variant: "secondary",
+      ...c,
+      children: l ?? /* @__PURE__ */ o(b, { size: 14 })
+    }
+  );
+});
+F.displayName = "CodeBlockCopyButton";
+const L = y(({ children: e, className: t, ...r }, l) => {
+  const { isCollapsed: s, setIsCollapsed: c, lineCount: n } = N(g);
+  return n <= 1 ? null : /* @__PURE__ */ o(
+    _,
+    {
+      ref: l,
+      "data-slot": "code-block-collapse-button",
+      className: d("shrink-0", t),
+      onClick: () => c(!s),
+      size: "icon",
+      variant: "secondary",
+      ...r,
+      children: e ?? /* @__PURE__ */ o($, { size: 14 })
+    }
+  );
+});
+L.displayName = "CodeBlockCollapseButton";
+export {
+  D as CodeBlock,
+  L as CodeBlockCollapseButton,
+  F as CodeBlockCopyButton
+};

package/dist/components/ui/core/code-block/code-block.metadata.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../../../lib/types';
+export declare const CodeBlockMetadata: ComponentMeta;

package/dist/components/ui/core/code-block/code-block.metadata.js

@@ -0,0 +1,8 @@
+const o = {
+  name: "CodeBlock",
+  status: "in-progress-code-review",
+  description: "A syntax-highlighted code block with copy and collapse functionality."
+};
+export {
+  o as CodeBlockMetadata
+};

package/dist/components/ui/core/collapsible/collapsible.d.ts

@@ -0,0 +1,4 @@
+declare const Collapsible: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').CollapsibleRootProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').CollapsibleTriggerProps, "ref"> & import('react').RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').CollapsiblePanelProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+export { Collapsible, CollapsibleContent, CollapsibleTrigger };

package/dist/components/ui/core/collapsible/collapsible.js

@@ -0,0 +1,44 @@
+import { jsx as a } from "react/jsx-runtime";
+import { forwardRef as t } from "react";
+import { Collapsible as i } from "@base-ui/react/collapsible";
+import { cn as s } from "../../../../lib/utils.js";
+const n = t(({ className: l, ...e }, o) => /* @__PURE__ */ a(
+  i.Root,
+  {
+    ref: o,
+    "data-slot": "collapsible",
+    className: s("w-full min-w-0 box-border *:max-w-full", l),
+    ...e
+  }
+));
+n.displayName = "Collapsible";
+const p = t(({ className: l, children: e, ...o }, r) => /* @__PURE__ */ a(
+  i.Trigger,
+  {
+    ref: r,
+    "data-slot": "collapsible-trigger",
+    className: s("group/collapsible-trigger text-base", l),
+    ...o,
+    children: e
+  }
+));
+p.displayName = "CollapsibleTrigger";
+const b = t(({ className: l, keepMounted: e = !0, ...o }, r) => /* @__PURE__ */ a(
+  i.Panel,
+  {
+    ref: r,
+    "data-slot": "collapsible-content",
+    className: s(
+      "hidden data-open:block border-none outline-none text-muted-foreground text-sm leading-4.5 tracking-tight w-full min-w-0 overflow-x-hidden box-border *:max-w-full *:box-border",
+      l
+    ),
+    keepMounted: e,
+    ...o
+  }
+));
+b.displayName = "CollapsibleContent";
+export {
+  n as Collapsible,
+  b as CollapsibleContent,
+  p as CollapsibleTrigger
+};

package/dist/components/ui/core/collapsible/collapsible.metadata.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../../../lib/types';
+export declare const CollapsibleMetadata: ComponentMeta;

package/dist/components/ui/core/collapsible/collapsible.metadata.js

@@ -0,0 +1,9 @@
+const e = {
+  name: "Collapsible",
+  status: "in-progress-code-review",
+  description: "An interactive component that expands/collapses content, built on Base UI Collapsible primitives.",
+  llmUsage: "Use `<Collapsible>` with `<CollapsibleTrigger>` and `<CollapsibleContent>` for expandable sections."
+};
+export {
+  e as CollapsibleMetadata
+};

package/dist/components/ui/core/command/command.d.ts

@@ -0,0 +1,86 @@
+import { ComponentProps, ReactNode } from 'react';
+import { Dialog } from '../dialog/dialog';
+declare const Command: import('react').ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof import('react').HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof import('react').HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & import('react').RefAttributes<HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+declare function CommandDialog({ title, description, children, className, showCloseButton, ...props }: Omit<ComponentProps<typeof Dialog>, 'children'> & {
+    children?: ReactNode;
+    title?: string;
+    description?: string;
+    className?: string;
+    showCloseButton?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare namespace CommandDialog {
+    var displayName: string;
+}
+declare const CommandInput: import('react').ForwardRefExoticComponent<Omit<Omit<Pick<Pick<import('react').DetailedHTMLProps<import('react').InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof import('react').InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof import('react').InputHTMLAttributes<HTMLInputElement> | "asChild">, "type" | "value" | "onChange"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & import('react').RefAttributes<HTMLInputElement>, "ref"> & import('react').RefAttributes<HTMLInputElement>>;
+declare const CommandList: import('react').ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof import('react').HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof import('react').HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string;
+} & import('react').RefAttributes<HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: import('react').ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof import('react').HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof import('react').HTMLAttributes<HTMLDivElement> | "asChild"> & import('react').RefAttributes<HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: import('react').ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof import('react').HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof import('react').HTMLAttributes<HTMLDivElement> | "asChild">, "value" | "heading"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & import('react').RefAttributes<HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: import('react').ForwardRefExoticComponent<Omit<Pick<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof import('react').HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof import('react').HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    alwaysRender?: boolean;
+} & import('react').RefAttributes<HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+declare const CommandItem: import('react').ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof import('react').HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof import('react').HTMLAttributes<HTMLDivElement> | "asChild">, "disabled" | "value" | "onSelect"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & import('react').RefAttributes<HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import('react').RefAttributes<HTMLSpanElement>>;
+export { Command, CommandDialog, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

package/dist/components/ui/core/command/command.js

@@ -0,0 +1,150 @@
+import { jsx as o, jsxs as n } from "react/jsx-runtime";
+import { forwardRef as d } from "react";
+import { IconSearch as p } from "@tabler/icons-react";
+import { Command as r } from "cmdk";
+import { cn as m } from "../../../../lib/utils.js";
+import { Dialog as u, DialogHeader as g, DialogTitle as h, DialogDescription as f, DialogContent as x } from "../dialog/dialog.js";
+const s = d(({ className: e, ...t }, a) => /* @__PURE__ */ o(
+  r,
+  {
+    ref: a,
+    "data-slot": "command",
+    className: m(
+      "rounded-lg bg-background text-muted-foreground flex h-full w-full flex-col overflow-hidden",
+      e
+    ),
+    ...t
+  }
+));
+s.displayName = "Command";
+function y({
+  title: e = "Command Palette",
+  description: t = "Search for a command to run...",
+  children: a,
+  className: l,
+  showCloseButton: c = !0,
+  ...i
+}) {
+  return /* @__PURE__ */ n(u, { ...i, children: [
+    /* @__PURE__ */ n(g, { className: "sr-only rounded-lg", children: [
+      /* @__PURE__ */ o(h, { children: e }),
+      /* @__PURE__ */ o(f, { children: t })
+    ] }),
+    /* @__PURE__ */ o(
+      x,
+      {
+        "data-slot": "command-dialog",
+        className: m("overflow-hidden p-0", l),
+        showCloseButton: c,
+        children: /* @__PURE__ */ o(s, { className: "**:[[cmdk-group-heading]]:text-muted-foreground **:data-[slot=command-input-wrapper]:h-12 **:[[cmdk-group-heading]]:px-2 **:[[cmdk-group-heading]]:font-medium **:[[cmdk-group]]:px-2 [&_[cmdk-group]:not([hidden])_~[cmdk-group]]:pt-0 [&_[cmdk-input-wrapper]_svg]:h-5 [&_[cmdk-input-wrapper]_svg]:w-5 **:[[cmdk-input]]:h-12 **:[[cmdk-item]]:px-2 **:[[cmdk-item]]:py-3 [&_[cmdk-item]_svg]:h-5 [&_[cmdk-item]_svg]:w-5", children: a })
+      }
+    )
+  ] });
+}
+y.displayName = "CommandDialog";
+const k = d(({ className: e, ...t }, a) => /* @__PURE__ */ n(
+  "div",
+  {
+    "data-slot": "command-input-wrapper",
+    className: "flex h-10 items-center gap-2 border-b px-2",
+    children: [
+      /* @__PURE__ */ o(p, { className: "size-4 shrink-0 opacity-50" }),
+      /* @__PURE__ */ o(
+        r.Input,
+        {
+          ref: a,
+          "data-slot": "command-input",
+          className: m(
+            "placeholder:text-muted-foreground flex h-10 w-full rounded-lg bg-transparent py-3 text-sm outline-hidden disabled:cursor-not-allowed disabled:opacity-50",
+            e
+          ),
+          ...t
+        }
+      )
+    ]
+  }
+));
+k.displayName = "CommandInput";
+const C = d(({ className: e, ...t }, a) => /* @__PURE__ */ o(
+  r.List,
+  {
+    ref: a,
+    "data-slot": "command-list",
+    className: m(
+      "max-h-75 scroll-py-1 overflow-x-hidden overflow-y-auto",
+      e
+    ),
+    ...t
+  }
+));
+C.displayName = "CommandList";
+const N = d(({ className: e, ...t }, a) => /* @__PURE__ */ o(
+  r.Empty,
+  {
+    ref: a,
+    "data-slot": "command-empty",
+    className: m("py-6 text-center text-sm", e),
+    ...t
+  }
+));
+N.displayName = "CommandEmpty";
+const v = d(({ className: e, ...t }, a) => /* @__PURE__ */ o(
+  r.Group,
+  {
+    ref: a,
+    "data-slot": "command-group",
+    className: m(
+      "text-popover-foreground font-normal **:[[cmdk-group-heading]]:text-muted-foreground overflow-hidden p-1 **:[[cmdk-group-heading]]:px-2 **:[[cmdk-group-heading]]:py-1.5 **:[[cmdk-group-heading]]:text-sm **:[[cmdk-group-heading]]:font-medium",
+      e
+    ),
+    ...t
+  }
+));
+v.displayName = "CommandGroup";
+const w = d(({ className: e, ...t }, a) => /* @__PURE__ */ o(
+  r.Separator,
+  {
+    ref: a,
+    "data-slot": "command-separator",
+    className: m("bg-border -mx-1 h-px", e),
+    ...t
+  }
+));
+w.displayName = "CommandSeparator";
+const _ = d(({ className: e, ...t }, a) => /* @__PURE__ */ o(
+  r.Item,
+  {
+    ref: a,
+    "data-slot": "command-item",
+    className: m(
+      "data-[selected=true]:bg-accent data-[selected=true]:text-accent-foreground [&_svg:not([class*='text-'])]:text-muted-foreground relative flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none data-[disabled=true]:pointer-events-none data-[disabled=true]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+      e
+    ),
+    ...t
+  }
+));
+_.displayName = "CommandItem";
+const b = d(({ className: e, ...t }, a) => /* @__PURE__ */ o(
+  "span",
+  {
+    ref: a,
+    "data-slot": "command-shortcut",
+    className: m(
+      "text-muted-foreground ml-auto text-xs tracking-widest",
+      e
+    ),
+    ...t
+  }
+));
+b.displayName = "CommandShortcut";
+export {
+  s as Command,
+  y as CommandDialog,
+  N as CommandEmpty,
+  v as CommandGroup,
+  k as CommandInput,
+  _ as CommandItem,
+  C as CommandList,
+  w as CommandSeparator,
+  b as CommandShortcut
+};

package/dist/components/ui/core/command/command.metadata.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../../../lib/types';
+export declare const CommandMetadata: ComponentMeta;

package/dist/components/ui/core/command/command.metadata.js

@@ -0,0 +1,9 @@
+const m = {
+  name: "Command",
+  status: "in-progress-code-review",
+  description: "A command menu component for searchable command palettes, built with cmdk.",
+  llmUsage: "Use `<Command>` with `<CommandInput>`, `<CommandList>`, and `<CommandItem>` for command palettes."
+};
+export {
+  m as CommandMetadata
+};

package/dist/components/ui/core/dialog/dialog.d.ts

@@ -0,0 +1,18 @@
+import { ComponentProps, ReactNode } from 'react';
+import { Dialog as DialogPrimitive } from '@base-ui/react/dialog';
+declare function Dialog({ ...props }: DialogPrimitive.Root.Props): import("react/jsx-runtime").JSX.Element;
+declare function DialogTrigger({ children, ...props }: DialogPrimitive.Trigger.Props): import("react/jsx-runtime").JSX.Element;
+declare function DialogPortal({ ...props }: DialogPrimitive.Portal.Props): import("react/jsx-runtime").JSX.Element;
+declare function DialogClose({ children, ...props }: DialogPrimitive.Close.Props & {
+    children?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DialogOverlay({ className, ...props }: DialogPrimitive.Backdrop.Props): import("react/jsx-runtime").JSX.Element;
+declare function DialogContent({ className, children, showCloseButton, closeButtonLabel, ...props }: DialogPrimitive.Popup.Props & {
+    showCloseButton?: boolean;
+    closeButtonLabel?: string;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DialogHeader({ className, ...props }: ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function DialogFooter({ className, ...props }: ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function DialogTitle({ className, ...props }: ComponentProps<typeof DialogPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function DialogDescription({ className, ...props }: DialogPrimitive.Description.Props): import("react/jsx-runtime").JSX.Element;
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, };