@skiddph/prui 0.1.0

package/dist/core/button.d.ts

@@ -0,0 +1,14 @@
+import { PropsMeta } from './props-meta';
+import * as React from "react";
+export type ButtonVariant = "primary" | "default" | "ghost" | "danger";
+export type ButtonSize = "sm" | "md" | "lg" | "icon";
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    /** Render the single child instead of a button element. */
+    asChild?: boolean;
+    /** Show a spinner and disable the button. */
+    loading?: boolean;
+}
+export declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export declare const buttonPropsMeta: PropsMeta;

package/dist/core/button.js

@@ -0,0 +1,58 @@
+import { jsx as r, jsxs as b, Fragment as g } from "react/jsx-runtime";
+import * as n from "react";
+import { Loader2 as h } from "lucide-react";
+import { cn as i } from "./cn.js";
+const v = {
+  primary: "bg-[var(--prui-brand)] text-[var(--prui-brand-fg)] hover:brightness-110 active:brightness-95",
+  default: "bg-[var(--prui-raise)] text-[var(--prui-fg)] border border-[var(--prui-line)] hover:border-[var(--prui-dim)]",
+  ghost: "bg-transparent text-[var(--prui-fg)] hover:bg-[var(--prui-raise)]",
+  danger: "bg-[var(--prui-danger)] text-white hover:brightness-110 active:brightness-95"
+}, x = {
+  sm: "h-7 px-2.5 text-xs gap-1.5",
+  md: "h-9 px-3.5 text-sm gap-2",
+  lg: "h-11 px-5 text-base gap-2",
+  icon: "h-9 w-9 p-0"
+}, y = n.forwardRef(
+  ({ className: d, variant: p = "default", size: c = "md", asChild: u = !1, loading: e = !1, disabled: m, children: t, ...o }, f) => {
+    const s = i(
+      "prui-button inline-flex items-center justify-center whitespace-nowrap font-medium select-none",
+      "transition-[filter,background-color,border-color] duration-150 outline-none cursor-pointer",
+      "focus-visible:ring-2 focus-visible:ring-[var(--prui-brand)] focus-visible:ring-offset-1",
+      "disabled:pointer-events-none disabled:opacity-50",
+      v[p],
+      x[c],
+      d
+    );
+    if (u && n.isValidElement(t)) {
+      const a = t;
+      return n.cloneElement(a, {
+        className: i(s, a.props.className),
+        ...o,
+        children: e ? /* @__PURE__ */ r(l, {}) : a.props.children
+      });
+    }
+    return /* @__PURE__ */ r("button", { ref: f, className: s, disabled: m || e, "data-loading": e || void 0, ...o, children: e ? /* @__PURE__ */ b(g, { children: [
+      /* @__PURE__ */ r(l, {}),
+      t
+    ] }) : t });
+  }
+);
+y.displayName = "Button";
+function l() {
+  return /* @__PURE__ */ r(h, { className: "h-4 w-4 animate-spin", "aria-hidden": !0 });
+}
+const B = {
+  name: "Button",
+  props: [
+    { name: "variant", type: "'primary' | 'default' | 'ghost' | 'danger'", default: "'default'", control: "select", options: ["primary", "default", "ghost", "danger"] },
+    { name: "size", type: "'sm' | 'md' | 'lg' | 'icon'", default: "'md'", control: "select", options: ["sm", "md", "lg", "icon"] },
+    { name: "asChild", type: "boolean", default: "false", control: "boolean" },
+    { name: "loading", type: "boolean", default: "false", control: "boolean" },
+    { name: "disabled", type: "boolean", default: "false", control: "boolean" },
+    { name: "children", type: "ReactNode", default: null, control: "text" }
+  ]
+};
+export {
+  y as Button,
+  B as buttonPropsMeta
+};

package/dist/core/card.d.ts

@@ -0,0 +1,24 @@
+import { PropsMeta } from './props-meta';
+import * as React from "react";
+export type BadgeVariant = "default" | "brand" | "ok" | "warn" | "danger" | "outline";
+export interface BadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
+    variant?: BadgeVariant;
+}
+export declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<HTMLSpanElement>>;
+export declare const badgePropsMeta: PropsMeta;
+export declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
+export declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export declare const cardPropsMeta: PropsMeta;
+export interface AvatarProps extends React.HTMLAttributes<HTMLSpanElement> {
+    src?: string;
+    alt?: string;
+    /** Fallback initials when no image or image fails. */
+    fallback?: string;
+    size?: "sm" | "md" | "lg";
+}
+export declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLSpanElement>>;
+export declare const avatarPropsMeta: PropsMeta;

package/dist/core/card.js

@@ -0,0 +1,122 @@
+import { jsx as t } from "react/jsx-runtime";
+import * as n from "react";
+import { cn as d } from "./cn.js";
+const g = {
+  default: "bg-[var(--prui-raise)] text-[var(--prui-fg)] border-transparent",
+  brand: "bg-[var(--prui-brand)]/15 text-[var(--prui-brand)] border-transparent",
+  ok: "bg-[var(--prui-ok)]/15 text-[var(--prui-ok)] border-transparent",
+  warn: "bg-[var(--prui-warn)]/15 text-[var(--prui-warn)] border-transparent",
+  danger: "bg-[var(--prui-danger)]/15 text-[var(--prui-danger)] border-transparent",
+  outline: "bg-transparent text-[var(--prui-fg)] border-[var(--prui-line)]"
+}, x = n.forwardRef(
+  ({ className: a, variant: e = "default", ...r }, i) => /* @__PURE__ */ t(
+    "span",
+    {
+      ref: i,
+      "data-variant": e,
+      className: d(
+        "prui-badge inline-flex items-center gap-1 rounded-[var(--prui-radius-full)] border px-2 py-0.5",
+        "text-xs font-medium whitespace-nowrap",
+        g[e],
+        a
+      ),
+      ...r
+    }
+  )
+);
+x.displayName = "Badge";
+const B = {
+  name: "Badge",
+  props: [
+    { name: "variant", type: "'default' | 'brand' | 'ok' | 'warn' | 'danger' | 'outline'", default: "'default'", control: "select", options: ["default", "brand", "ok", "warn", "danger", "outline"] },
+    { name: "children", type: "ReactNode", default: null, control: "text" }
+  ]
+}, b = n.forwardRef(
+  ({ className: a, ...e }, r) => /* @__PURE__ */ t(
+    "div",
+    {
+      ref: r,
+      className: d(
+        "prui-card rounded-[var(--prui-radius)] border border-[var(--prui-line)] bg-[var(--prui-surface)]",
+        a
+      ),
+      ...e
+    }
+  )
+);
+b.displayName = "Card";
+const w = n.forwardRef(
+  ({ className: a, ...e }, r) => /* @__PURE__ */ t("div", { ref: r, className: d("prui-card-header flex flex-col gap-1 p-4", a), ...e })
+);
+w.displayName = "CardHeader";
+const N = n.forwardRef(
+  ({ className: a, ...e }, r) => /* @__PURE__ */ t("h3", { ref: r, className: d("prui-card-title text-base font-semibold text-[var(--prui-fg)]", a), ...e })
+);
+N.displayName = "CardTitle";
+const y = n.forwardRef(
+  ({ className: a, ...e }, r) => /* @__PURE__ */ t("p", { ref: r, className: d("prui-card-description text-sm text-[var(--prui-dim)]", a), ...e })
+);
+y.displayName = "CardDescription";
+const C = n.forwardRef(
+  ({ className: a, ...e }, r) => /* @__PURE__ */ t("div", { ref: r, className: d("prui-card-content p-4 pt-0", a), ...e })
+);
+C.displayName = "CardContent";
+const h = n.forwardRef(
+  ({ className: a, ...e }, r) => /* @__PURE__ */ t("div", { ref: r, className: d("prui-card-footer flex items-center p-4 pt-0", a), ...e })
+);
+h.displayName = "CardFooter";
+const F = {
+  name: "Card",
+  props: [
+    { name: "children", type: "ReactNode", default: null, control: "text" },
+    { name: "className", type: "string", default: "undefined", control: "text" }
+  ]
+}, R = {
+  sm: "h-6 w-6 text-[10px]",
+  md: "h-8 w-8 text-xs",
+  lg: "h-12 w-12 text-base"
+}, k = n.forwardRef(
+  ({ className: a, src: e, alt: r, fallback: i, size: s = "md", ...l }, p) => {
+    const [u, c] = n.useState(!1), f = e && !u, m = i ?? (r ? r.split(/\s+/).slice(0, 2).map((v) => {
+      var o;
+      return ((o = v[0]) == null ? void 0 : o.toUpperCase()) ?? "";
+    }).join("") : "");
+    return /* @__PURE__ */ t(
+      "span",
+      {
+        ref: p,
+        className: d(
+          "prui-avatar relative inline-flex shrink-0 select-none items-center justify-center overflow-hidden",
+          "rounded-[var(--prui-radius-full)] bg-[var(--prui-raise)] text-[var(--prui-dim)] font-medium",
+          R[s],
+          a
+        ),
+        ...l,
+        children: f ? /* @__PURE__ */ t("img", { src: e, alt: r ?? "", className: "h-full w-full object-cover", onError: () => c(!0) }) : m
+      }
+    );
+  }
+);
+k.displayName = "Avatar";
+const M = {
+  name: "Avatar",
+  props: [
+    { name: "src", type: "string", default: "undefined", control: "text" },
+    { name: "alt", type: "string", default: "undefined", control: "text" },
+    { name: "fallback", type: "string", default: "initials from alt", control: "text" },
+    { name: "size", type: "'sm' | 'md' | 'lg'", default: "'md'", control: "select", options: ["sm", "md", "lg"] }
+  ]
+};
+export {
+  k as Avatar,
+  x as Badge,
+  b as Card,
+  C as CardContent,
+  y as CardDescription,
+  h as CardFooter,
+  w as CardHeader,
+  N as CardTitle,
+  M as avatarPropsMeta,
+  B as badgePropsMeta,
+  F as cardPropsMeta
+};

package/dist/core/cn.d.ts

@@ -0,0 +1,3 @@
+import { ClassValue } from 'clsx';
+/** Merge class names; tailwind-aware. */
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/core/cn.js

@@ -0,0 +1,8 @@
+import { clsx as o } from "clsx";
+import { twMerge as t } from "tailwind-merge";
+function n(...r) {
+  return t(o(r));
+}
+export {
+  n as cn
+};

package/dist/core/dialog.d.ts

@@ -0,0 +1,25 @@
+import { PropsMeta } from './props-meta';
+import * as React from "react";
+export interface DialogProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Called to confirm a controlled close (X / backdrop / Escape). */
+    onClose?: () => void;
+    children?: React.ReactNode;
+}
+export declare const Dialog: {
+    ({ open: openProp, defaultOpen, onOpenChange, children }: DialogProps): React.JSX.Element;
+    displayName: string;
+};
+export interface DialogContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Accessibility label when no DialogTitle is rendered. */
+    ariaLabel?: string;
+    hideClose?: boolean;
+}
+export declare const DialogContent: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
+export declare const DialogHeader: ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => React.JSX.Element;
+export declare const DialogTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
+export declare const DialogDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export declare const DialogFooter: ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => React.JSX.Element;
+export declare const dialogPropsMeta: PropsMeta;

package/dist/core/dialog.js

@@ -0,0 +1,102 @@
+import { jsx as a, jsxs as y } from "react/jsx-runtime";
+import * as l from "react";
+import { X as x } from "lucide-react";
+import { cn as d } from "./cn.js";
+const m = l.createContext(null);
+function v() {
+  const e = l.useContext(m);
+  if (!e) throw new Error("Dialog parts must be used inside <Dialog>");
+  return e;
+}
+const w = ({ open: e, defaultOpen: o = !1, onOpenChange: t, children: n }) => {
+  const [c, p] = l.useState(o), u = e !== void 0, s = u ? e : c, i = l.useId(), f = (r) => {
+    u || p(r), t == null || t(r);
+  };
+  return /* @__PURE__ */ a(m.Provider, { value: { open: s, setOpen: f, labelId: i }, children: n });
+};
+w.displayName = "Dialog";
+const D = l.forwardRef(
+  ({ className: e, children: o, ariaLabel: t, hideClose: n, onClick: c, ...p }, u) => {
+    const { open: s, setOpen: i, labelId: f } = v();
+    return l.useEffect(() => {
+      if (!s) return;
+      const r = (b) => {
+        b.key === "Escape" && i(!1);
+      };
+      document.addEventListener("keydown", r);
+      const g = document.body.style.overflow;
+      return document.body.style.overflow = "hidden", () => {
+        document.removeEventListener("keydown", r), document.body.style.overflow = g;
+      };
+    }, [s, i]), s ? /* @__PURE__ */ a(
+      "div",
+      {
+        className: "prui-dialog-overlay fixed inset-0 z-50 flex items-center justify-center p-4",
+        style: { backgroundColor: "rgba(0,0,0,0.55)" },
+        onMouseDown: (r) => {
+          r.target === r.currentTarget && i(!1);
+        },
+        children: /* @__PURE__ */ y(
+          "div",
+          {
+            ref: u,
+            role: "dialog",
+            "aria-modal": "true",
+            "aria-label": t,
+            "aria-labelledby": t ? void 0 : f,
+            className: d(
+              "prui-dialog-content relative z-10 w-full max-w-lg rounded-[var(--prui-radius)]",
+              "border border-[var(--prui-line)] bg-[var(--prui-surface)] shadow-xl",
+              "max-h-[85vh] overflow-auto outline-none",
+              e
+            ),
+            onClick: c,
+            ...p,
+            children: [
+              o,
+              n ? null : /* @__PURE__ */ a(
+                "button",
+                {
+                  type: "button",
+                  "aria-label": "Close",
+                  onClick: () => i(!1),
+                  className: "absolute right-3 top-3 rounded-[var(--prui-radius-1)] p-1 text-[var(--prui-dim)] hover:text-[var(--prui-fg)] hover:bg-[var(--prui-raise)] cursor-pointer",
+                  children: /* @__PURE__ */ a(x, { className: "h-4 w-4", "aria-hidden": !0 })
+                }
+              )
+            ]
+          }
+        )
+      }
+    ) : null;
+  }
+);
+D.displayName = "DialogContent";
+const j = ({ className: e, ...o }) => /* @__PURE__ */ a("div", { className: d("prui-dialog-header flex flex-col gap-1 p-4 pb-2", e), ...o }), h = l.forwardRef(
+  ({ className: e, ...o }, t) => {
+    const { labelId: n } = v();
+    return /* @__PURE__ */ a("h2", { ref: t, id: n, className: d("prui-dialog-title text-base font-semibold text-[var(--prui-fg)]", e), ...o });
+  }
+);
+h.displayName = "DialogTitle";
+const N = l.forwardRef(
+  ({ className: e, ...o }, t) => /* @__PURE__ */ a("p", { ref: t, className: d("prui-dialog-description text-sm text-[var(--prui-dim)]", e), ...o })
+);
+N.displayName = "DialogDescription";
+const I = ({ className: e, ...o }) => /* @__PURE__ */ a("div", { className: d("prui-dialog-footer flex items-center justify-end gap-2 p-4 pt-2", e), ...o }), R = {
+  name: "Dialog",
+  props: [
+    { name: "open", type: "boolean", default: "undefined", control: "boolean" },
+    { name: "defaultOpen", type: "boolean", default: "false", control: "boolean" },
+    { name: "onOpenChange", type: "(open: boolean) => void", default: null, control: "none" }
+  ]
+};
+export {
+  w as Dialog,
+  D as DialogContent,
+  N as DialogDescription,
+  I as DialogFooter,
+  j as DialogHeader,
+  h as DialogTitle,
+  R as dialogPropsMeta
+};

package/dist/core/dropdown.d.ts

@@ -0,0 +1,24 @@
+import { PropsMeta } from './props-meta';
+import * as React from "react";
+export interface DropdownItem {
+    label: string;
+    onSelect?: () => void;
+    danger?: boolean;
+    disabled?: boolean;
+    separatorBefore?: boolean;
+}
+export interface DropdownProps {
+    items?: DropdownItem[];
+    trigger?: React.ReactNode;
+    children?: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    align?: "start" | "end";
+    className?: string;
+}
+export declare const Dropdown: {
+    ({ items, trigger, children, open: openProp, defaultOpen, onOpenChange, align, className, }: DropdownProps): React.JSX.Element;
+    displayName: string;
+};
+export declare const dropdownPropsMeta: PropsMeta;

package/dist/core/dropdown.js

@@ -0,0 +1,89 @@
+import { jsxs as p, jsx as a } from "react/jsx-runtime";
+import * as l from "react";
+import { cn as i } from "./cn.js";
+const k = ({
+  items: f,
+  trigger: m,
+  children: v,
+  open: u,
+  defaultOpen: b = !1,
+  onOpenChange: d,
+  align: y = "start",
+  className: w
+}) => {
+  const [x, g] = l.useState(b), c = u !== void 0, n = c ? u : x, s = l.useRef(null), o = (e) => {
+    c || g(e), d == null || d(e);
+  };
+  return l.useEffect(() => {
+    if (!n) return;
+    const e = (r) => {
+      s.current && !s.current.contains(r.target) && o(!1);
+    }, t = (r) => {
+      r.key === "Escape" && o(!1);
+    };
+    return document.addEventListener("mousedown", e), document.addEventListener("keydown", t), () => {
+      document.removeEventListener("mousedown", e), document.removeEventListener("keydown", t);
+    };
+  }), /* @__PURE__ */ p("div", { ref: s, className: i("prui-dropdown relative inline-block", w), "data-state": n ? "open" : "closed", children: [
+    /* @__PURE__ */ a(
+      "div",
+      {
+        role: "button",
+        tabIndex: 0,
+        "aria-haspopup": "menu",
+        "aria-expanded": n,
+        onClick: () => o(!n),
+        onKeyDown: (e) => {
+          (e.key === "Enter" || e.key === " ") && (e.preventDefault(), o(!n));
+        },
+        children: m
+      }
+    ),
+    n ? /* @__PURE__ */ a(
+      "div",
+      {
+        role: "menu",
+        className: i(
+          "prui-dropdown-menu absolute z-50 mt-1 min-w-40 rounded-[var(--prui-radius)] border border-[var(--prui-line)]",
+          "bg-[var(--prui-surface)] p-1 shadow-lg",
+          y === "end" ? "right-0" : "left-0"
+        ),
+        children: v ?? (f ?? []).map((e, t) => /* @__PURE__ */ p(l.Fragment, { children: [
+          e.separatorBefore ? /* @__PURE__ */ a("div", { className: "my-1 h-px bg-[var(--prui-line)]" }) : null,
+          /* @__PURE__ */ a(
+            "button",
+            {
+              type: "button",
+              role: "menuitem",
+              disabled: e.disabled,
+              onClick: () => {
+                var r;
+                e.disabled || (o(!1), (r = e.onSelect) == null || r.call(e));
+              },
+              className: i(
+                "flex w-full items-center rounded-[calc(var(--prui-radius)-1px)] px-2.5 py-1.5 text-left text-sm",
+                "hover:bg-[var(--prui-raise)] cursor-pointer disabled:opacity-50 disabled:pointer-events-none",
+                e.danger ? "text-[var(--prui-danger)]" : "text-[var(--prui-fg)]"
+              ),
+              children: e.label
+            }
+          )
+        ] }, `${e.label}-${t}`))
+      }
+    ) : null
+  ] });
+};
+k.displayName = "Dropdown";
+const E = {
+  name: "Dropdown",
+  props: [
+    { name: "items", type: "DropdownItem[]", default: "[]", control: "object" },
+    { name: "trigger", type: "ReactNode", default: null, control: "none" },
+    { name: "align", type: "'start' | 'end'", default: "'start'", control: "select", options: ["start", "end"] },
+    { name: "onOpenChange", type: "(open: boolean) => void", default: null, control: "none" }
+  ]
+};
+export {
+  k as Dropdown,
+  E as dropdownPropsMeta
+};

package/dist/core/index.d.ts

@@ -0,0 +1,14 @@
+/** PRUI primitives layer: standard composition building blocks plus cn(). */
+export { cn } from './cn';
+export type { PropsMeta, PropMeta, PropControl } from './props-meta';
+export { Button, buttonPropsMeta, type ButtonProps, type ButtonVariant, type ButtonSize, } from './button';
+export { Input, inputPropsMeta, Textarea, textareaPropsMeta, type InputProps, type TextareaProps, } from './input';
+export { Label, labelPropsMeta, Separator, separatorPropsMeta, type LabelProps, type SeparatorProps } from './label';
+export { Select, SelectTrigger, SelectValue, SelectContent, SelectItem, selectPropsMeta, type SelectProps, type SelectOption, type SelectTriggerProps, type SelectValueProps, type SelectContentProps, type SelectItemProps, } from './select';
+export { Switch, switchPropsMeta, type SwitchProps } from './switch';
+export { Tabs, TabsList, TabsTrigger, TabsContent, tabsPropsMeta, type TabsProps, type TabsListProps, type TabsTriggerProps, type TabsContentProps, } from './tabs';
+export { Badge, badgePropsMeta, Card, CardHeader, CardTitle, CardDescription, CardContent, CardFooter, cardPropsMeta, Avatar, avatarPropsMeta, type BadgeProps, type BadgeVariant, type AvatarProps, } from './card';
+export { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, DialogFooter, dialogPropsMeta, type DialogProps, type DialogContentProps, } from './dialog';
+export { Dropdown, dropdownPropsMeta, type DropdownProps, type DropdownItem, } from './dropdown';
+export { ScrollArea, scrollAreaPropsMeta, type ScrollAreaProps } from './scroll-area';
+export { Modal, confirmModal, modalPropsMeta, confirmModalPropsMeta, type ModalProps, type ModalSize, type ConfirmModalOptions, type ConfirmModalType, } from './modal';

package/dist/core/input.d.ts

@@ -0,0 +1,8 @@
+import { PropsMeta } from './props-meta';
+import * as React from "react";
+export type InputProps = React.InputHTMLAttributes<HTMLInputElement>;
+export declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export declare const inputPropsMeta: PropsMeta;
+export type TextareaProps = React.TextareaHTMLAttributes<HTMLTextAreaElement>;
+export declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export declare const textareaPropsMeta: PropsMeta;

package/dist/core/input.js

@@ -0,0 +1,42 @@
+import { jsx as r } from "react/jsx-runtime";
+import * as n from "react";
+import { cn as o } from "./cn.js";
+const l = "prui-input w-full bg-[var(--prui-background)] text-[var(--prui-fg)] placeholder:text-[var(--prui-dim)] border border-[var(--prui-line)] rounded-[var(--prui-radius)] px-3 h-9 text-sm outline-none transition-colors focus:border-[var(--prui-brand)] focus:ring-2 focus:ring-[var(--prui-brand)]/30 disabled:opacity-50 disabled:cursor-not-allowed", u = n.forwardRef(
+  ({ className: e, type: t = "text", ...a }, p) => /* @__PURE__ */ r("input", { ref: p, type: t, className: o(l, e), ...a })
+);
+u.displayName = "Input";
+const c = {
+  name: "Input",
+  props: [
+    { name: "type", type: "string", default: "'text'", control: "select", options: ["text", "password", "email", "number", "search"] },
+    { name: "value", type: "string", default: null, control: "text" },
+    { name: "placeholder", type: "string", default: "undefined", control: "text" },
+    { name: "disabled", type: "boolean", default: "false", control: "boolean" },
+    { name: "onChange", type: "(e) => void", default: null, control: "none" }
+  ]
+}, i = n.forwardRef(
+  ({ className: e, ...t }, a) => /* @__PURE__ */ r(
+    "textarea",
+    {
+      ref: a,
+      className: o(l, "h-auto min-h-20 py-2 resize-y", e),
+      ...t
+    }
+  )
+);
+i.displayName = "Textarea";
+const m = {
+  name: "Textarea",
+  props: [
+    { name: "value", type: "string", default: null, control: "textarea" },
+    { name: "placeholder", type: "string", default: "undefined", control: "text" },
+    { name: "rows", type: "number", default: "4", control: "number" },
+    { name: "onChange", type: "(e) => void", default: null, control: "none" }
+  ]
+};
+export {
+  u as Input,
+  i as Textarea,
+  c as inputPropsMeta,
+  m as textareaPropsMeta
+};

package/dist/core/label.d.ts

@@ -0,0 +1,12 @@
+import { PropsMeta } from './props-meta';
+import * as React from "react";
+export type LabelProps = React.LabelHTMLAttributes<HTMLLabelElement>;
+export declare const Label: React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLLabelElement>>;
+export declare const labelPropsMeta: PropsMeta;
+export type SeparatorProps = React.HTMLAttributes<HTMLDivElement> & {
+    orientation?: "horizontal" | "vertical";
+};
+export declare const Separator: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    orientation?: "horizontal" | "vertical";
+} & React.RefAttributes<HTMLDivElement>>;
+export declare const separatorPropsMeta: PropsMeta;

package/dist/core/label.js

@@ -0,0 +1,52 @@
+import { jsx as t } from "react/jsx-runtime";
+import * as o from "react";
+import { cn as l } from "./cn.js";
+const i = o.forwardRef(
+  ({ className: e, ...a }, r) => /* @__PURE__ */ t(
+    "label",
+    {
+      ref: r,
+      className: l(
+        "prui-label block text-sm font-medium text-[var(--prui-fg)] select-none",
+        e
+      ),
+      ...a
+    }
+  )
+);
+i.displayName = "Label";
+const c = {
+  name: "Label",
+  props: [
+    { name: "htmlFor", type: "string", default: "undefined", control: "text" },
+    { name: "children", type: "ReactNode", default: null, control: "text" }
+  ]
+}, p = o.forwardRef(
+  ({ className: e, orientation: a = "horizontal", ...r }, n) => /* @__PURE__ */ t(
+    "div",
+    {
+      ref: n,
+      role: "separator",
+      "aria-orientation": a,
+      className: l(
+        "prui-separator shrink-0 bg-[var(--prui-line)]",
+        a === "horizontal" ? "h-px w-full" : "w-px h-full min-h-4",
+        e
+      ),
+      ...r
+    }
+  )
+);
+p.displayName = "Separator";
+const f = {
+  name: "Separator",
+  props: [
+    { name: "orientation", type: "'horizontal' | 'vertical'", default: "'horizontal'", control: "select", options: ["horizontal", "vertical"] }
+  ]
+};
+export {
+  i as Label,
+  p as Separator,
+  c as labelPropsMeta,
+  f as separatorPropsMeta
+};