@a2ui-sdk/react 0.0.0

package/dist/0.9/utils/dataBinding.js

@@ -0,0 +1,41 @@
+import { resolvePath as f, getValueByPath as c } from "./pathUtils.js";
+import { interpolate as y } from "@a2ui-sdk/utils/0.9";
+function e(r) {
+  return r != null && typeof r == "object" && !Array.isArray(r) && "path" in r && typeof r.path == "string";
+}
+function p(r) {
+  return r != null && typeof r == "object" && !Array.isArray(r) && "call" in r && typeof r.call == "string";
+}
+function g(r, i, o = null, t) {
+  if (r == null)
+    return t;
+  if (e(r)) {
+    const s = f(r.path, o), n = c(i, s);
+    return n === void 0 ? t : n;
+  }
+  return p(r) ? t : r;
+}
+function l(r, i, o = null, t = "") {
+  if (r == null)
+    return t;
+  if (e(r)) {
+    const s = f(r.path, o), n = c(i, s);
+    return n == null ? t : String(n);
+  }
+  return p(r) ? t : typeof r == "string" ? y(r, i, o) : String(r);
+}
+function m(r, i, o = null) {
+  if (!r)
+    return {};
+  const t = {};
+  for (const [s, n] of Object.entries(r))
+    t[s] = g(n, i, o);
+  return t;
+}
+export {
+  p as isFunctionCall,
+  e as isPathBinding,
+  m as resolveContext,
+  l as resolveString,
+  g as resolveValue
+};

package/dist/0.9/utils/pathUtils.d.ts

@@ -0,0 +1,109 @@
+import { DataModel } from '@a2ui-sdk/types/0.9';
+/**
+ * Parses a JSON Pointer path into segments.
+ *
+ * @param path - The JSON Pointer path (e.g., "/user/name")
+ * @returns Array of path segments
+ *
+ * @example
+ * parseJsonPointer("/user/name");        // ["user", "name"]
+ * parseJsonPointer("/items/0");          // ["items", "0"]
+ * parseJsonPointer("/");                 // []
+ * parseJsonPointer("/a~1b");             // ["a/b"] (escaped slash)
+ * parseJsonPointer("/m~0n");             // ["m~n"] (escaped tilde)
+ */
+export declare function parseJsonPointer(path: string): string[];
+/**
+ * Creates a JSON Pointer path from segments.
+ *
+ * @param segments - Array of path segments
+ * @returns JSON Pointer path string
+ *
+ * @example
+ * createJsonPointer(["user", "name"]);   // "/user/name"
+ * createJsonPointer(["a/b"]);            // "/a~1b"
+ * createJsonPointer([]);                 // "/"
+ */
+export declare function createJsonPointer(segments: string[]): string;
+/**
+ * Gets a value from the data model by JSON Pointer path.
+ *
+ * @param dataModel - The data model to read from
+ * @param path - The JSON Pointer path (e.g., "/user/name")
+ * @returns The value at the path, or undefined if not found
+ *
+ * @example
+ * const model = { user: { name: "John" }, items: ["a", "b"] };
+ * getValueByPath(model, "/user/name");   // "John"
+ * getValueByPath(model, "/items/0");     // "a"
+ * getValueByPath(model, "/nonexistent"); // undefined
+ */
+export declare function getValueByPath(dataModel: DataModel, path: string): unknown;
+/**
+ * Sets a value in the data model by JSON Pointer path, returning a new data model.
+ * This function is immutable - it does not modify the original data model.
+ *
+ * @param dataModel - The data model to update
+ * @param path - The JSON Pointer path (e.g., "/user/name")
+ * @param value - The value to set (undefined to delete)
+ * @returns A new data model with the value set
+ *
+ * @example
+ * const model = { user: { name: "John" } };
+ * setValueByPath(model, "/user/name", "Jane");   // { user: { name: "Jane" } }
+ * setValueByPath(model, "/user/age", 30);        // { user: { name: "John", age: 30 } }
+ * setValueByPath(model, "/user/name", undefined); // { user: {} }
+ */
+export declare function setValueByPath(dataModel: DataModel, path: string, value: unknown): DataModel;
+/**
+ * Normalizes a path to ensure it starts with "/" and has no trailing "/".
+ *
+ * @param path - The path to normalize
+ * @returns The normalized path
+ *
+ * @example
+ * normalizePath("user/name");   // "/user/name"
+ * normalizePath("/user/name/"); // "/user/name"
+ */
+export declare function normalizePath(path: string): string;
+/**
+ * Checks if a path is absolute (starts with "/").
+ *
+ * @param path - The path to check
+ * @returns True if the path is absolute
+ *
+ * @example
+ * isAbsolutePath("/user/name");  // true
+ * isAbsolutePath("name");        // false
+ * isAbsolutePath("");            // false
+ */
+export declare function isAbsolutePath(path: string): boolean;
+/**
+ * Resolves a path against a base path (scope).
+ *
+ * Absolute paths (starting with "/") are returned as-is.
+ * Relative paths are resolved against the base path.
+ *
+ * @param path - The path to resolve
+ * @param basePath - The base path (scope), or null for root scope
+ * @returns The resolved absolute path
+ *
+ * @example
+ * resolvePath("/user/name", "/items/0");   // "/user/name" (absolute)
+ * resolvePath("name", "/items/0");         // "/items/0/name" (relative)
+ * resolvePath("name", null);               // "/name" (root scope)
+ */
+export declare function resolvePath(path: string, basePath: string | null): string;
+/**
+ * Joins two paths together.
+ *
+ * @param basePath - The base path
+ * @param relativePath - The relative path to join
+ * @returns The joined path
+ *
+ * @example
+ * joinPaths("/user", "name");     // "/user/name"
+ * joinPaths("/user", "/name");    // "/user/name"
+ * joinPaths("/user/", "/name/");  // "/user/name"
+ */
+export declare function joinPaths(basePath: string, relativePath: string): string;

package/dist/0.9/utils/pathUtils.js

@@ -0,0 +1,74 @@
+function y(t) {
+  return !t || t === "/" ? [] : (t.startsWith("/") ? t.slice(1).split("/") : t.split("/")).filter((r) => r !== "").map((r) => r.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function m(t, e) {
+  if (!e || e === "/")
+    return t;
+  const r = y(e);
+  let i = t;
+  for (const f of r) {
+    if (i == null)
+      return;
+    if (Array.isArray(i)) {
+      const n = parseInt(f, 10);
+      if (isNaN(n))
+        return;
+      i = i[n];
+    } else if (typeof i == "object")
+      i = i[f];
+    else
+      return;
+  }
+  return i;
+}
+function a(t, e, r) {
+  if (!e || e === "/")
+    return r === void 0 ? {} : typeof r == "object" && r !== null && !Array.isArray(r) ? r : t;
+  const i = y(e), f = structuredClone(t);
+  let n = f;
+  for (let o = 0; o < i.length - 1; o++) {
+    const l = i[o];
+    if (Array.isArray(n)) {
+      const s = parseInt(l, 10);
+      if (isNaN(s))
+        return f;
+      (n[s] === null || n[s] === void 0) && (n[s] = {}), n = n[s];
+    } else if (typeof n == "object" && n !== null) {
+      const s = n;
+      s[l] === null || s[l] === void 0 ? s[l] = {} : typeof s[l] != "object" && (s[l] = {}), n = s[l];
+    } else
+      return f;
+  }
+  const c = i[i.length - 1];
+  if (Array.isArray(n)) {
+    const o = parseInt(c, 10);
+    isNaN(o) || (r === void 0 ? n.splice(o, 1) : n[o] = r);
+  } else if (typeof n == "object" && n !== null) {
+    const o = n;
+    r === void 0 ? delete o[c] : o[c] = r;
+  }
+  return f;
+}
+function u(t) {
+  let e = t.trim();
+  return e.startsWith("/") || (e = "/" + e), e.length > 1 && e.endsWith("/") && (e = e.slice(0, -1)), e;
+}
+function g(t) {
+  return t.startsWith("/");
+}
+function A(t, e) {
+  return g(t) || e === null || e === "/" ? u(t) : d(e, t);
+}
+function d(t, e) {
+  const r = u(t), i = e.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+  return i ? r === "/" ? "/" + i : r + "/" + i : r;
+}
+export {
+  m as getValueByPath,
+  g as isAbsolutePath,
+  d as joinPaths,
+  u as normalizePath,
+  y as parseJsonPointer,
+  A as resolvePath,
+  a as setValueByPath
+};

package/dist/0.9/utils/validation.d.ts

@@ -0,0 +1,49 @@
+import { CheckRule, DynamicValue, DataModel, ValidationResult } from '@a2ui-sdk/types/0.9';
+/**
+ * Type for a validation function.
+ * Takes resolved arguments and returns a boolean.
+ */
+export type ValidationFunction = (args: Record<string, unknown>) => boolean;
+/**
+ * Built-in validation functions.
+ */
+export declare const validationFunctions: Record<string, ValidationFunction>;
+/**
+ * Context for evaluating expressions.
+ */
+export interface EvaluationContext {
+    dataModel: DataModel;
+    basePath: string | null;
+    functions?: Record<string, ValidationFunction>;
+}
+/**
+ * Resolves function arguments from DynamicValue to actual values.
+ */
+export declare function resolveArgs(args: Record<string, DynamicValue> | undefined, dataModel: DataModel, basePath: string | null): Record<string, unknown>;
+/**
+ * Evaluates a function call.
+ */
+export declare function evaluateFunctionCall(call: string, args: Record<string, DynamicValue> | undefined, context: EvaluationContext): boolean;
+/**
+ * Evaluates a CheckRule (which is also a LogicExpression).
+ *
+ * @param rule - The check rule to evaluate
+ * @param context - Evaluation context with data model and scope
+ * @returns true if the check passes, false if it fails
+ */
+export declare function evaluateCheckRule(rule: CheckRule, context: EvaluationContext): boolean;
+/**
+ * Evaluates all checks for a component and returns validation result.
+ *
+ * @param checks - Array of check rules
+ * @param dataModel - The data model for value resolution
+ * @param basePath - The current scope base path (for relative paths)
+ * @param functions - Optional custom validation functions
+ * @returns ValidationResult with valid flag and error messages
+ */
+export declare function evaluateChecks(checks: CheckRule[] | undefined, dataModel: DataModel, basePath: string | null, functions?: Record<string, ValidationFunction>): ValidationResult;
+/**
+ * Extracts all paths referenced in a CheckRule for dependency tracking.
+ * This is useful for knowing which data model paths affect validation.
+ */
+export declare function extractCheckDependencies(checks: CheckRule[]): string[];

package/dist/0.9/utils/validation.js

@@ -0,0 +1,75 @@
+import { resolveValue as l } from "./dataBinding.js";
+const a = {
+  /**
+   * Checks if a value is present (not null, undefined, or empty string).
+   */
+  required: ({ value: r }) => r == null ? !1 : typeof r == "string" ? r.trim().length > 0 : Array.isArray(r) ? r.length > 0 : !0,
+  /**
+   * Validates email format.
+   */
+  email: ({ value: r }) => typeof r != "string" ? !1 : /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(r),
+  /**
+   * Tests value against a regular expression pattern.
+   */
+  regex: ({ value: r, pattern: e }) => {
+    if (typeof r != "string" || typeof e != "string") return !1;
+    try {
+      return new RegExp(e).test(r);
+    } catch {
+      return !1;
+    }
+  },
+  /**
+   * Validates string length within min/max bounds.
+   */
+  length: ({ value: r, min: e, max: n }) => {
+    const s = String(r ?? "").length;
+    return !(e != null && s < Number(e) || n != null && s > Number(n));
+  },
+  /**
+   * Validates numeric value within min/max bounds.
+   */
+  numeric: ({ value: r, min: e, max: n }) => {
+    const t = Number(r);
+    return !(isNaN(t) || e != null && t < Number(e) || n != null && t > Number(n));
+  }
+};
+function c(r, e, n) {
+  if (!r) return {};
+  const t = {};
+  for (const [s, i] of Object.entries(r))
+    t[s] = l(i, e, n, void 0);
+  return t;
+}
+function g(r, e, n) {
+  const { dataModel: t, basePath: s, functions: i = a } = n, o = i[r];
+  if (!o)
+    return console.warn(`[A2UI] Unknown validation function: ${r}`), !0;
+  const u = c(e, t, s);
+  return o(u);
+}
+function f(r, e) {
+  return "and" in r && r.and ? r.and.every((n) => f(n, e)) : "or" in r && r.or ? r.or.some((n) => f(n, e)) : "not" in r && r.not ? !f(r.not, e) : "true" in r && r.true === !0 ? !0 : "false" in r && r.false === !1 ? !1 : "call" in r && r.call ? g(r.call, r.args, e) : !0;
+}
+function v(r, e, n, t) {
+  if (!r || r.length === 0)
+    return { valid: !0, errors: [] };
+  const s = {
+    dataModel: e,
+    basePath: n,
+    functions: t ?? a
+  }, i = [];
+  for (const o of r)
+    !f(o, s) && o.message && i.push(o.message);
+  return {
+    valid: i.length === 0,
+    errors: i
+  };
+}
+export {
+  f as evaluateCheckRule,
+  v as evaluateChecks,
+  g as evaluateFunctionCall,
+  c as resolveArgs,
+  a as validationFunctions
+};

package/dist/components/ui/button.d.ts

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "icon" | "sm" | "lg" | "icon-sm" | "icon-lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<'button'> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { Button, buttonVariants };

package/dist/components/ui/button.js

@@ -0,0 +1,53 @@
+import { jsx as o } from "react/jsx-runtime";
+import { Slot as a } from "@radix-ui/react-slot";
+import { cva as s } from "class-variance-authority";
+import { cn as d } from "../../lib/utils.js";
+const u = s(
+  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-all disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/90",
+        destructive: "bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
+        outline: "border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
+        link: "text-primary underline-offset-4 hover:underline"
+      },
+      size: {
+        default: "h-9 px-4 py-2 has-[>svg]:px-3",
+        sm: "h-8 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5",
+        lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
+        icon: "size-9",
+        "icon-sm": "size-8",
+        "icon-lg": "size-10"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+function b({
+  className: t,
+  variant: e = "default",
+  size: r = "default",
+  asChild: i = !1,
+  ...n
+}) {
+  return /* @__PURE__ */ o(
+    i ? a : "button",
+    {
+      "data-slot": "button",
+      "data-variant": e,
+      "data-size": r,
+      className: d(u({ variant: e, size: r, className: t })),
+      ...n
+    }
+  );
+}
+export {
+  b as Button,
+  u as buttonVariants
+};

package/dist/components/ui/card.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+declare function Card({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardHeader({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardTitle({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardDescription({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardAction({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardContent({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function CardFooter({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent, };

package/dist/components/ui/card.js

@@ -0,0 +1,29 @@
+import { jsx as t } from "react/jsx-runtime";
+import { cn as a } from "../../lib/utils.js";
+function n({ className: r, ...o }) {
+  return /* @__PURE__ */ t(
+    "div",
+    {
+      "data-slot": "card",
+      className: a(
+        "bg-card text-card-foreground flex flex-col gap-6 rounded-xl border py-6 shadow-sm",
+        r
+      ),
+      ...o
+    }
+  );
+}
+function c({ className: r, ...o }) {
+  return /* @__PURE__ */ t(
+    "div",
+    {
+      "data-slot": "card-content",
+      className: a("px-6", r),
+      ...o
+    }
+  );
+}
+export {
+  n as Card,
+  c as CardContent
+};

package/dist/components/ui/checkbox.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+declare function Checkbox({ className, ...props }: React.ComponentProps<typeof CheckboxPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Checkbox };

package/dist/components/ui/checkbox.js

@@ -0,0 +1,31 @@
+import { jsx as r } from "react/jsx-runtime";
+import * as e from "@radix-ui/react-checkbox";
+import { CheckIcon as t } from "lucide-react";
+import { cn as o } from "../../lib/utils.js";
+function s({
+  className: i,
+  ...a
+}) {
+  return /* @__PURE__ */ r(
+    e.Root,
+    {
+      "data-slot": "checkbox",
+      className: o(
+        "peer border-input dark:bg-input/30 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground dark:data-[state=checked]:bg-primary data-[state=checked]:border-primary focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive size-4 shrink-0 rounded-[4px] border shadow-xs transition-shadow outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50",
+        i
+      ),
+      ...a,
+      children: /* @__PURE__ */ r(
+        e.Indicator,
+        {
+          "data-slot": "checkbox-indicator",
+          className: "grid place-content-center text-current transition-none",
+          children: /* @__PURE__ */ r(t, { className: "size-3.5" })
+        }
+      )
+    }
+  );
+}
+export {
+  s as Checkbox
+};

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

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

package/dist/components/ui/dialog.js

@@ -0,0 +1,77 @@
+import { jsx as a, jsxs as n } from "react/jsx-runtime";
+import * as o from "@radix-ui/react-dialog";
+import { XIcon as l } from "lucide-react";
+import { cn as i } from "../../lib/utils.js";
+function m({
+  ...t
+}) {
+  return /* @__PURE__ */ a(o.Root, { "data-slot": "dialog", ...t });
+}
+function p({
+  ...t
+}) {
+  return /* @__PURE__ */ a(o.Trigger, { "data-slot": "dialog-trigger", ...t });
+}
+function d({
+  ...t
+}) {
+  return /* @__PURE__ */ a(o.Portal, { "data-slot": "dialog-portal", ...t });
+}
+function g({
+  className: t,
+  ...e
+}) {
+  return /* @__PURE__ */ a(
+    o.Overlay,
+    {
+      "data-slot": "dialog-overlay",
+      className: i(
+        "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50",
+        t
+      ),
+      ...e
+    }
+  );
+}
+function v({
+  className: t,
+  children: e,
+  showCloseButton: s = !0,
+  ...r
+}) {
+  return /* @__PURE__ */ n(d, { "data-slot": "dialog-portal", children: [
+    /* @__PURE__ */ a(g, {}),
+    /* @__PURE__ */ n(
+      o.Content,
+      {
+        "data-slot": "dialog-content",
+        className: i(
+          "bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 outline-none sm:max-w-lg",
+          t
+        ),
+        ...r,
+        children: [
+          e,
+          s && /* @__PURE__ */ n(
+            o.Close,
+            {
+              "data-slot": "dialog-close",
+              className: "ring-offset-background focus:ring-ring data-[state=open]:bg-accent data-[state=open]:text-muted-foreground absolute top-4 right-4 rounded-xs opacity-70 transition-opacity hover:opacity-100 focus:ring-2 focus:ring-offset-2 focus:outline-hidden disabled:pointer-events-none [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+              children: [
+                /* @__PURE__ */ a(l, {}),
+                /* @__PURE__ */ a("span", { className: "sr-only", children: "Close" })
+              ]
+            }
+          )
+        ]
+      }
+    )
+  ] });
+}
+export {
+  m as Dialog,
+  v as DialogContent,
+  g as DialogOverlay,
+  d as DialogPortal,
+  p as DialogTrigger
+};

package/dist/components/ui/input.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare function Input({ className, type, ...props }: React.ComponentProps<'input'>): import("react/jsx-runtime").JSX.Element;
+export { Input };

package/dist/components/ui/input.js

@@ -0,0 +1,21 @@
+import { jsx as t } from "react/jsx-runtime";
+import { cn as n } from "../../lib/utils.js";
+function a({ className: e, type: i, ...r }) {
+  return /* @__PURE__ */ t(
+    "input",
+    {
+      type: i,
+      "data-slot": "input",
+      className: n(
+        "file:text-foreground placeholder:text-muted-foreground selection:bg-primary selection:text-primary-foreground dark:bg-input/30 border-input h-9 w-full min-w-0 rounded-md border bg-transparent px-3 py-1 text-base shadow-xs transition-[color,box-shadow] outline-none file:inline-flex file:h-7 file:border-0 file:bg-transparent file:text-sm file:font-medium disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
+        "focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]",
+        "aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
+        e
+      ),
+      ...r
+    }
+  );
+}
+export {
+  a as Input
+};

package/dist/components/ui/label.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import * as LabelPrimitive from '@radix-ui/react-label';
+declare function Label({ className, ...props }: React.ComponentProps<typeof LabelPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Label };

package/dist/components/ui/label.js

@@ -0,0 +1,22 @@
+import { jsx as o } from "react/jsx-runtime";
+import * as a from "@radix-ui/react-label";
+import { cn as r } from "../../lib/utils.js";
+function l({
+  className: e,
+  ...t
+}) {
+  return /* @__PURE__ */ o(
+    a.Root,
+    {
+      "data-slot": "label",
+      className: r(
+        "flex items-center gap-2 text-sm leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50",
+        e
+      ),
+      ...t
+    }
+  );
+}
+export {
+  l as Label
+};

package/dist/components/ui/native-select.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+declare function NativeSelect({ className, size, ...props }: Omit<React.ComponentProps<'select'>, 'size'> & {
+    size?: 'sm' | 'default';
+}): import("react/jsx-runtime").JSX.Element;
+declare function NativeSelectOption({ ...props }: React.ComponentProps<'option'>): import("react/jsx-runtime").JSX.Element;
+declare function NativeSelectOptGroup({ className, ...props }: React.ComponentProps<'optgroup'>): import("react/jsx-runtime").JSX.Element;
+export { NativeSelect, NativeSelectOptGroup, NativeSelectOption };