@pebble-software/bonsai 0.1.0 → 0.1.2

package/dist/chunks/builder.meta-WpXc5VBB.js

@@ -0,0 +1,666 @@
+import { z as e } from "zod";
+import { COMPONENT as t } from "../constants.js";
+const r = e.object({
+  id: e.string().optional().meta({ description: "Unique identifier for the element" }),
+  className: e.string().optional().meta({ description: "CSS classes to apply to the element" })
+}), ye = r.extend({
+  href: e.string({ error: "Link destination (href) is required" }).min(1, { message: "Link destination (href) cannot be empty" })
+}), Se = r.extend({
+  variant: e.enum(["h1", "h2", "h3", "h4", "h5", "h6"], {
+    error: "Invalid heading variant. Must be one of: h1, h2, h3, h4, h5, or h6"
+  }).optional().meta({ description: "Heading level variant (h1-h6)" }),
+  as: e.enum(["h1", "h2", "h3", "h4", "h5", "h6"], {
+    error: "Invalid heading element type. Must be one of: h1, h2, h3, h4, h5, or h6"
+  }).optional().meta({ description: "Render as a different heading element" })
+}).optional(), Le = r.extend({
+  size: e.enum(["xs", "sm", "md", "lg", "xl"], {
+    error: "Invalid paragraph size. Must be one of: xs, sm, md, lg, or xl"
+  }).optional().meta({ description: "Paragraph text size" }),
+  variant: e.enum(["default", "muted"]).optional().meta({ description: "Paragraph style variant" }),
+  as: e.enum(["p", "div", "span"]).optional().meta({ description: "Render as a different element" })
+}).optional(), ve = r.optional(), _e = r.optional(), Pe = r.optional(), De = r.optional(), fe = r.optional(), Be = r.optional(), Ue = r.extend({
+  variant: e.enum(["default", "success", "warning", "destructive"], {
+    error: "Invalid alert variant. Must be one of: default, success, warning, or destructive"
+  }).optional().meta({ description: "Alert style variant" }),
+  size: e.enum(["default", "sm", "lg"]).optional().meta({ description: "Alert size" }),
+  raised: e.enum(["xs", "sm", "md", "lg", "xl"]).optional().meta({ description: "Alert shadow elevation" })
+}).optional(), we = r.extend({
+  variant: e.enum(["default", "secondary", "destructive", "outline", "ghost"], {
+    error: "Invalid badge variant. Must be one of: default, secondary, destructive, outline, or ghost"
+  }).optional().meta({ description: "Badge style variant" }),
+  size: e.enum(["sm", "md", "lg"]).optional().meta({ description: "Badge size" }),
+  raised: e.enum(["xs", "sm", "md", "lg"]).optional().meta({ description: "Badge shadow elevation" }),
+  extrude: e.enum(["xs", "sm", "md", "lg"]).optional().meta({ description: "Badge extrude elevation" })
+}).optional(), Ge = r.extend({
+  variant: e.enum(["default", "secondary", "outline", "destructive", "warning", "ghost"], {
+    error: "Invalid button variant. Must be one of: default, secondary, outline, destructive, warning, or ghost"
+  }).optional().meta({ description: "Button style variant" }),
+  size: e.enum(["xs", "sm", "md", "lg"], {
+    error: "Invalid button size. Must be one of: xs, sm, md, or lg"
+  }).optional().meta({ description: "Button size" }),
+  icon: e.enum(["xs", "sm", "md", "lg"]).optional().meta({ description: "Icon-only button size" }),
+  raised: e.enum(["xs", "sm", "md", "lg", "xl"]).optional().meta({ description: "Button shadow elevation" }),
+  extrude: e.enum(["xs", "sm", "md", "lg", "xl"]).optional().meta({ description: "Button extrude elevation" }),
+  disabled: e.union([e.string(), e.boolean()]).optional().meta({ description: "Whether the button is disabled" }),
+  loading: e.union([e.string(), e.boolean()]).optional().meta({ description: "Whether to show a loading spinner" }),
+  type: e.enum(["button", "submit"], {
+    error: "Invalid button type. Must be either 'button' or 'submit'"
+  }).optional().meta({ description: "Button type attribute" })
+}).optional(), ke = r.extend({
+  size: e.enum(["sm", "md"]).optional().meta({ description: "Card size" }),
+  raised: e.enum(["none", "xs", "sm", "md", "lg", "xl"]).optional().meta({ description: "Card shadow elevation" })
+}).optional(), He = r.optional(), ze = r.optional(), Me = r.optional(), We = r.optional(), Fe = r.optional(), je = r.optional(), qe = r.optional(), Xe = r.extend({
+  checked: e.union([e.string(), e.boolean()]).optional().meta({ description: "Checkbox checked state" }),
+  disabled: e.union([e.string(), e.boolean()]).optional().meta({ description: "Whether the checkbox is disabled" }),
+  required: e.union([e.string(), e.boolean()]).optional().meta({ description: "Whether the checkbox must be checked" }),
+  size: e.enum(["xs", "sm", "md", "lg", "xl"]).optional().meta({ description: "Checkbox size" })
+}).strict(), Ve = r.extend({
+  src: e.union(
+    [
+      e.url({ error: "Image source (src) must be a valid URL" }),
+      e.string().min(1, { message: "Image source (src) cannot be empty" })
+    ],
+    {
+      error: "Image source (src) is required"
+    }
+  ),
+  alt: e.string().optional().default("unknown image url").meta({ description: "Alternative text for the image" })
+}).strict(), Ke = r.extend({
+  value: e.union([e.string(), e.number()], {
+    error: "OTP value is required"
+  }).meta({ description: "Current OTP value" }),
+  placeholder: e.string().optional().meta({ description: "Placeholder text for the OTP input" }),
+  disabled: e.union([e.string(), e.boolean()]).optional().meta({ description: "Whether the OTP input is disabled" }),
+  containerClassName: e.string().optional().meta({ description: "Custom CSS class for the OTP input container" })
+}).strict(), Ye = r.extend({
+  type: e.enum(["text", "email", "password", "number"], {
+    error: "Invalid input type. Must be one of: text, email, password, or number"
+  }).optional().meta({ description: "Input type; a number input stores a number" }),
+  value: e.union([e.string(), e.number()], {
+    error: "Input value is required"
+  }).meta({ description: "Current input value" }),
+  placeholder: e.string().optional().meta({ description: "Placeholder text shown when empty" }),
+  disabled: e.union([e.string(), e.boolean()]).optional().meta({ description: "Whether the input is disabled" })
+}).strict(), Ze = r.extend({
+  htmlFor: e.string().min(1, {
+    message: "Label 'for' attribute is required and must reference an input ID"
+  }).meta({ description: "ID of the associated input element" }),
+  size: e.enum(["xs", "sm", "md", "lg", "xl"]).optional().meta({ description: "Label text size" }),
+  variant: e.enum(["default", "underline", "destructive"]).optional().meta({ description: "Label style variant" })
+}).strict(), Je = r.extend({
+  checked: e.union([e.string(), e.boolean()], {
+    error: "Switch checked state is required"
+  }).meta({ description: "Current switch state" }),
+  disabled: e.union([e.string(), e.boolean()]).optional().meta({ description: "Whether the switch is disabled" }),
+  required: e.union([e.string(), e.boolean()]).optional().meta({ description: "Whether the switch must be turned on" }),
+  size: e.enum(["sm", "md", "lg"]).optional().meta({ description: "Switch size" }),
+  rounded: e.enum(["none", "sm", "md", "lg", "full"]).optional().meta({ description: "Switch border radius" })
+}).strict(), Qe = r.extend({
+  value: e.string({ error: "Textarea value is required" }).meta({ description: "Current textarea content" }),
+  placeholder: e.string().optional().meta({ description: "Placeholder text shown when empty" }),
+  disabled: e.union([e.string(), e.boolean()]).optional().meta({ description: "Whether the textarea is disabled" }),
+  autosize: e.boolean().optional().meta({ description: "Whether the textarea auto-resizes to fit content" }),
+  rows: e.number().min(1, { message: "Minimum number of rows is 1" }).max(100, { message: "Maximum number of rows is 100" }).optional().meta({ description: "Number of visible text lines" }),
+  minLength: e.number().min(0, { message: "Minimum character length cannot be negative" }).optional().meta({ description: "Minimum number of characters allowed" }),
+  maxLength: e.number().max(1e4, { message: "Maximum character length cannot exceed 10,000" }).optional().meta({ description: "Maximum number of characters allowed" })
+}).strict(), $e = r.optional(), et = r.optional(), tt = r.extend({
+  align: e.enum(["inline-start", "inline-end", "block-start", "block-end"]).optional().meta({ description: "Alignment of the addon within the input group" })
+}).optional(), nt = r.extend({
+  value: e.union([e.string(), e.number()], {
+    error: "Input value is required"
+  }).meta({ description: "Current input value" }),
+  placeholder: e.string().optional().meta({ description: "Placeholder text shown when empty" }),
+  disabled: e.union([e.string(), e.boolean()]).optional().meta({ description: "Whether the input is disabled" })
+}).strict(), at = r.extend({
+  variant: e.enum(["default", "secondary", "outline", "destructive", "warning", "ghost"]).optional(),
+  size: e.enum(["xs", "sm", "md", "lg"]).optional()
+}).optional(), ot = r.extend({
+  value: e.string({ error: "Textarea value is required" }).meta({ description: "Current textarea content" }),
+  placeholder: e.string().optional(),
+  disabled: e.union([e.string(), e.boolean()]).optional()
+}).strict(), it = r.extend({
+  value: e.string().nullable().meta({ description: "Current signature value (base64 or null if empty)" }),
+  canvasClassname: e.string().optional().meta({ description: "Custom CSS class for the signature canvas" }),
+  imageType: e.enum(["image/png", "image/jpeg", "image/webp"]).optional().meta({ description: "Image format for the exported signature" })
+}).strict(), rt = r.extend({
+  selected: e.union([e.string(), e.date(), e.array(e.date())], {
+    error: "Invalid calendar selection. Must be a date string, Date object, or array of dates"
+  }).optional().meta({ description: "Currently selected date(s)" }),
+  buttonVariant: e.enum(["default", "secondary", "outline", "destructive", "warning", "ghost"]).optional().meta({ description: "Variant for calendar navigation buttons" }),
+  hideWeekends: e.boolean().optional().meta({ description: "Whether to hide Saturday and Sunday columns" })
+}).optional(), st = r.optional(), lt = r.optional(), dt = r.optional(), ct = r.optional(), pt = r.optional(), mt = r.optional(), gt = r.optional(), ut = r.optional(), At = r.extend({
+  variant: e.enum(["default", "contained", "separated"]).optional().meta({ description: "Accordion style variant" }),
+  raised: e.enum(["xs", "sm", "md", "lg"]).optional().meta({ description: "Accordion shadow elevation" }),
+  extrude: e.enum(["xs", "sm", "md", "lg"]).optional().meta({ description: "Accordion extrude elevation" })
+}).optional(), ht = r.optional(), Tt = r.extend({
+  disabled: e.union([e.string(), e.boolean()]).optional().meta({ description: "Whether the accordion trigger is disabled" }),
+  icon: e.any().optional().meta({ description: "Custom icon component for the trigger" })
+}).optional(), bt = r.optional(), Ct = r.extend({
+  src: e.string().optional().meta({ description: "Image source URL" }),
+  alt: e.string().optional().meta({ description: "Alternative text for the avatar image" }),
+  size: e.enum(["full", "sm", "md", "lg", "xl"]).optional().meta({ description: "Avatar size" }),
+  rounded: e.enum(["none", "sm", "md", "lg", "full"]).optional().meta({ description: "Avatar border radius" }),
+  raised: e.enum(["xs", "sm", "md", "lg"]).optional().meta({ description: "Avatar shadow elevation" }),
+  fallback: e.string().optional().meta({ description: "Fallback text or element when image fails to load" }),
+  badge: e.any().optional().meta({ description: "Badge element to overlay on the avatar" })
+}).optional(), xt = r.optional(), Nt = r.optional(), Et = r.optional(), Ot = r.extend({
+  variant: e.enum(["spinner", "ping"]).optional().meta({ description: "Loader animation variant" }),
+  fill: e.enum(["default", "destructive", "warning", "pending"]).optional().meta({ description: "Loader fill color" }),
+  size: e.enum(["sm", "md", "lg"]).optional().meta({ description: "Loader size" }),
+  icon: e.any().optional().meta({ description: "Custom spinner icon component" }),
+  pingIcon: e.any().optional().meta({ description: "Custom ping icon component" }),
+  iconProps: e.any().optional().meta({ description: "Props to pass to the icon components" })
+}).optional(), It = r.extend({
+  mode: e.enum(["single", "multiple"]).optional().meta({ description: "Progress display mode" }),
+  value: e.union([
+    e.number().nullable(),
+    e.array(
+      e.object({
+        name: e.string().optional(),
+        value: e.number()
+      })
+    )
+  ]).optional().meta({ description: "Current progress value(s)" }),
+  size: e.enum(["xs", "sm", "md", "lg", "xl"]).optional().meta({ description: "Progress size" }),
+  raised: e.enum(["default", "xs", "sm", "md", "lg", "xl"]).optional().meta({ description: "Progress shadow elevation" }),
+  stacked: e.enum(["default", "xs", "sm", "md", "lg", "xl"]).optional().meta({ description: "Progress stacked spacing" })
+}).optional(), Rt = r.extend({
+  variant: e.enum(["circle", "square", "default", "text"]).optional().meta({ description: "Skeleton shape variant" }),
+  animate: e.boolean().optional().meta({ description: "Whether to animate the skeleton" })
+}).optional(), yt = e.lazy(() => e.union([e.string(), Ee])), i = e.object({
+  children: e.array(yt).optional().meta({ description: "Child nodes to render inside this element" })
+}), b = i.extend({
+  type: e.literal(t.DIV),
+  args: De
+}).meta({ description: "Container div element for grouping content" }), C = i.extend({
+  type: e.literal(t.A),
+  args: ye
+}).meta({ description: "Anchor/link element" }), x = i.extend({
+  type: e.literal(t.H),
+  args: Se
+}).meta({ description: "Heading element (h1-h6)" }), N = i.extend({
+  type: e.literal(t.P),
+  args: Le
+}).meta({ description: "Paragraph text element" }), E = i.extend({
+  type: e.literal(t.OL),
+  args: ve
+}).meta({ description: "Ordered list element" }), O = i.extend({
+  type: e.literal(t.UL),
+  args: _e
+}).meta({ description: "Unordered list element" }), I = i.extend({
+  type: e.literal(t.LI),
+  args: Pe
+}).meta({ description: "List item element" }), R = i.extend({
+  type: e.literal(t.SPAN),
+  args: fe
+}).meta({ description: "Inline span element" }), y = i.extend({
+  type: e.literal(t.SEPARATOR),
+  args: Be
+}).meta({ description: "Horizontal separator / divider element" }), S = i.extend({
+  type: e.literal(t.ALERT),
+  args: Ue
+}).meta({ description: "Alert message box" }), L = i.extend({
+  type: e.literal(t.BADGE),
+  args: we
+}).meta({ description: "Badge/status indicator" }), v = i.extend({
+  type: e.literal(t.BUTTON),
+  args: Ge
+}).meta({ description: "Clickable button element" }), _ = i.extend({
+  type: e.literal(t.CARD),
+  args: ke
+}).meta({ description: "Card container element" }), P = i.extend({
+  type: e.literal(t.CHECKBOX),
+  args: Xe
+}).meta({ description: "Checkbox input element" }), D = i.extend({
+  type: e.literal(t.IMAGE),
+  args: Ve
+}).meta({ description: "Image element" }), f = i.extend({
+  type: e.literal(t.OTP),
+  args: Ke
+}).meta({ description: "One-time password (OTP) input" }), B = i.extend({
+  type: e.literal(t.INPUT),
+  args: Ye
+}).meta({ description: "Text input element" }), U = i.extend({
+  type: e.literal(t.LABEL),
+  args: Ze
+}).meta({ description: "Form label element" }), w = i.extend({
+  type: e.literal(t.SWITCH),
+  args: Je
+}).meta({ description: "Toggle switch element" }), G = i.extend({
+  type: e.literal(t.TEXTAREA),
+  args: Qe
+}).meta({ description: "Multi-line text input" }), k = i.extend({
+  type: e.literal(t.SIGNATURE),
+  args: it
+}).meta({ description: "Signature pad input" }), H = i.extend({
+  type: e.literal(t.CALENDAR),
+  args: rt
+}).meta({ description: "Date picker calendar" }), z = i.extend({
+  type: e.literal(t.CARD_HEADER),
+  args: He
+}).meta({ description: "Card header container" }), M = i.extend({
+  type: e.literal(t.CARD_TITLE),
+  args: ze
+}).meta({ description: "Card title element" }), W = i.extend({
+  type: e.literal(t.CARD_DESCRIPTION),
+  args: Me
+}).meta({ description: "Card description element" }), F = i.extend({
+  type: e.literal(t.CARD_CONTENT),
+  args: We
+}).meta({ description: "Card content body" }), j = i.extend({
+  type: e.literal(t.CARD_FOOTER),
+  args: Fe
+}).meta({ description: "Card footer container" }), q = i.extend({
+  type: e.literal(t.CARD_ACTION),
+  args: je
+}).meta({ description: "Card action slot" }), X = i.extend({
+  type: e.literal(t.CARD_ICON),
+  args: qe
+}).meta({ description: "Card icon slot" }), V = i.extend({
+  type: e.literal(t.TABLE),
+  args: st
+}).meta({ description: "Table container" }), K = i.extend({
+  type: e.literal(t.TABLE_HEADER),
+  args: lt
+}).meta({ description: "Table header section" }), Y = i.extend({
+  type: e.literal(t.TABLE_BODY),
+  args: dt
+}).meta({ description: "Table body section" }), Z = i.extend({
+  type: e.literal(t.TABLE_FOOTER),
+  args: ct
+}).meta({ description: "Table footer section" }), J = i.extend({
+  type: e.literal(t.TABLE_HEAD),
+  args: pt
+}).meta({ description: "Table header cell" }), Q = i.extend({
+  type: e.literal(t.TABLE_ROW),
+  args: mt
+}).meta({ description: "Table row" }), $ = i.extend({
+  type: e.literal(t.TABLE_CELL),
+  args: gt
+}).meta({ description: "Table data cell" }), ee = i.extend({
+  type: e.literal(t.TABLE_CAPTION),
+  args: ut
+}).meta({ description: "Table caption" }), te = i.extend({
+  type: e.literal(t.ACCORDION),
+  args: At
+}).meta({ description: "Accordion container" }), ne = i.extend({
+  type: e.literal(t.ACCORDION_ITEM),
+  args: ht
+}).meta({ description: "Accordion item" }), ae = i.extend({
+  type: e.literal(t.ACCORDION_TRIGGER),
+  args: Tt
+}).meta({ description: "Accordion trigger" }), oe = i.extend({
+  type: e.literal(t.ACCORDION_CONTENT),
+  args: bt
+}).meta({ description: "Accordion content panel" }), ie = i.extend({
+  type: e.literal(t.AVATAR),
+  args: Ct
+}).meta({ description: "Avatar image or fallback" }), re = i.extend({
+  type: e.literal(t.COLLAPSIBLE),
+  args: xt
+}).meta({ description: "Collapsible container" }), se = i.extend({
+  type: e.literal(t.COLLAPSIBLE_TRIGGER),
+  args: Nt
+}).meta({ description: "Collapsible trigger" }), le = i.extend({
+  type: e.literal(t.COLLAPSIBLE_CONTENT),
+  args: Et
+}).meta({ description: "Collapsible content panel" }), de = i.extend({
+  type: e.literal(t.LOADER),
+  args: Ot
+}).meta({ description: "Loading spinner indicator" }), ce = i.extend({
+  type: e.literal(t.PROGRESS),
+  args: It
+}).meta({ description: "Progress bar indicator" }), pe = i.extend({
+  type: e.literal(t.SKELETON),
+  args: Rt
+}).meta({ description: "Skeleton loading placeholder" }), me = i.extend({
+  type: e.literal(t.INPUT_GROUP),
+  args: $e
+}).meta({ description: "Input group container" }), ge = i.extend({
+  type: e.literal(t.INPUT_GROUP_TEXT),
+  args: et
+}).meta({ description: "Text element within input group" }), ue = i.extend({
+  type: e.literal(t.INPUT_GROUP_ADDON),
+  args: tt
+}).meta({ description: "Addon container within input group" }), Ae = i.extend({
+  type: e.literal(t.INPUT_GROUP_INPUT),
+  args: nt
+}).meta({ description: "Input element within input group" }), he = i.extend({
+  type: e.literal(t.INPUT_GROUP_BUTTON),
+  args: at
+}).meta({ description: "Button element within input group" }), Te = i.extend({
+  type: e.literal(t.INPUT_GROUP_TEXTAREA),
+  args: ot
+}).meta({ description: "Textarea element within input group" }), St = e.object({
+  items: e.string({ error: "each.items is required" }).min(1, { message: "each.items cannot be empty" }).meta({
+    description: 'Binding path to the array to iterate, e.g. "{{applicants}}". Must be a plain path (not a computed/filtered expression) so each row maps back to a real store index for two-way binding.'
+  }),
+  as: e.string({ error: "each.as is required" }).min(1, { message: "each.as cannot be empty" }).meta({ description: 'Alias name bound to the current item, e.g. "applicant"' }),
+  index: e.string().optional().meta({ description: "Alias name bound to the current numeric index" }),
+  key: e.string().optional().meta({
+    description: 'Binding expression used as the React key per row, e.g. "{{applicant.id}}". Falls back to the row index when omitted.'
+  })
+}).strict(), be = i.extend({
+  type: e.literal(t.EACH),
+  args: St
+}).meta({ description: "Repeats its children once per item in a bound array" }), Lt = e.object({
+  condition: e.string({ error: "if.condition is required" }).min(1, { message: "if.condition cannot be empty" }).meta({ description: "Binding expression; children render only when it evaluates truthy" })
+}).strict(), Ce = i.extend({
+  type: e.literal(t.IF),
+  args: Lt
+}).meta({ description: "Conditionally renders its children based on a bound expression" });
+function a(s) {
+  return s.shape.args;
+}
+function o(s) {
+  return s.meta()?.description;
+}
+function vt(s) {
+  if (Object.keys(s).length === 0)
+    throw new Error("createTemplateSchema: registry must declare at least one component");
+  let l;
+  const d = e.lazy(() => e.union([e.string(), l])), c = e.object({
+    children: e.array(d).optional().meta({ description: "Child nodes to render inside this element" })
+  }), g = Object.entries(s).map(([Ie, { argsSchema: Re, description: h }]) => {
+    const T = c.extend({
+      type: e.literal(Ie),
+      args: Re
+    });
+    return h ? T.meta({ description: h }) : T;
+  });
+  return l = e.discriminatedUnion(
+    "type",
+    g
+  ), { Node: d, ComponentNode: l };
+}
+const _t = {
+  [t.DIV]: { argsSchema: a(b), description: o(b) },
+  [t.A]: { argsSchema: a(C), description: o(C) },
+  [t.H]: { argsSchema: a(x), description: o(x) },
+  [t.P]: { argsSchema: a(N), description: o(N) },
+  [t.OL]: { argsSchema: a(E), description: o(E) },
+  [t.UL]: { argsSchema: a(O), description: o(O) },
+  [t.LI]: { argsSchema: a(I), description: o(I) },
+  [t.SPAN]: { argsSchema: a(R), description: o(R) },
+  [t.SEPARATOR]: {
+    argsSchema: a(y),
+    description: o(y)
+  },
+  [t.ALERT]: { argsSchema: a(S), description: o(S) },
+  [t.BADGE]: { argsSchema: a(L), description: o(L) },
+  [t.BUTTON]: { argsSchema: a(v), description: o(v) },
+  [t.CARD]: { argsSchema: a(_), description: o(_) },
+  [t.CARD_HEADER]: {
+    argsSchema: a(z),
+    description: o(z)
+  },
+  [t.CARD_TITLE]: {
+    argsSchema: a(M),
+    description: o(M)
+  },
+  [t.CARD_DESCRIPTION]: {
+    argsSchema: a(W),
+    description: o(W)
+  },
+  [t.CARD_CONTENT]: {
+    argsSchema: a(F),
+    description: o(F)
+  },
+  [t.CARD_FOOTER]: {
+    argsSchema: a(j),
+    description: o(j)
+  },
+  [t.CARD_ACTION]: {
+    argsSchema: a(q),
+    description: o(q)
+  },
+  [t.CARD_ICON]: {
+    argsSchema: a(X),
+    description: o(X)
+  },
+  [t.CHECKBOX]: {
+    argsSchema: a(P),
+    description: o(P)
+  },
+  [t.IMAGE]: { argsSchema: a(D), description: o(D) },
+  [t.OTP]: { argsSchema: a(f), description: o(f) },
+  [t.INPUT]: { argsSchema: a(B), description: o(B) },
+  [t.LABEL]: { argsSchema: a(U), description: o(U) },
+  [t.SWITCH]: { argsSchema: a(w), description: o(w) },
+  [t.TEXTAREA]: {
+    argsSchema: a(G),
+    description: o(G)
+  },
+  [t.SIGNATURE]: {
+    argsSchema: a(k),
+    description: o(k)
+  },
+  [t.CALENDAR]: {
+    argsSchema: a(H),
+    description: o(H)
+  },
+  [t.TABLE]: { argsSchema: a(V), description: o(V) },
+  [t.TABLE_HEADER]: {
+    argsSchema: a(K),
+    description: o(K)
+  },
+  [t.TABLE_BODY]: {
+    argsSchema: a(Y),
+    description: o(Y)
+  },
+  [t.TABLE_FOOTER]: {
+    argsSchema: a(Z),
+    description: o(Z)
+  },
+  [t.TABLE_HEAD]: {
+    argsSchema: a(J),
+    description: o(J)
+  },
+  [t.TABLE_ROW]: {
+    argsSchema: a(Q),
+    description: o(Q)
+  },
+  [t.TABLE_CELL]: {
+    argsSchema: a($),
+    description: o($)
+  },
+  [t.TABLE_CAPTION]: {
+    argsSchema: a(ee),
+    description: o(ee)
+  },
+  [t.ACCORDION]: {
+    argsSchema: a(te),
+    description: o(te)
+  },
+  [t.ACCORDION_ITEM]: {
+    argsSchema: a(ne),
+    description: o(ne)
+  },
+  [t.ACCORDION_TRIGGER]: {
+    argsSchema: a(ae),
+    description: o(ae)
+  },
+  [t.ACCORDION_CONTENT]: {
+    argsSchema: a(oe),
+    description: o(oe)
+  },
+  [t.AVATAR]: { argsSchema: a(ie), description: o(ie) },
+  [t.COLLAPSIBLE]: {
+    argsSchema: a(re),
+    description: o(re)
+  },
+  [t.COLLAPSIBLE_TRIGGER]: {
+    argsSchema: a(se),
+    description: o(se)
+  },
+  [t.COLLAPSIBLE_CONTENT]: {
+    argsSchema: a(le),
+    description: o(le)
+  },
+  [t.LOADER]: { argsSchema: a(de), description: o(de) },
+  [t.PROGRESS]: {
+    argsSchema: a(ce),
+    description: o(ce)
+  },
+  [t.SKELETON]: {
+    argsSchema: a(pe),
+    description: o(pe)
+  },
+  [t.INPUT_GROUP]: {
+    argsSchema: a(me),
+    description: o(me)
+  },
+  [t.INPUT_GROUP_TEXT]: {
+    argsSchema: a(ge),
+    description: o(ge)
+  },
+  [t.INPUT_GROUP_ADDON]: {
+    argsSchema: a(ue),
+    description: o(ue)
+  },
+  [t.INPUT_GROUP_INPUT]: {
+    argsSchema: a(Ae),
+    description: o(Ae)
+  },
+  [t.INPUT_GROUP_BUTTON]: {
+    argsSchema: a(he),
+    description: o(he)
+  },
+  [t.INPUT_GROUP_TEXTAREA]: {
+    argsSchema: a(Te),
+    description: o(Te)
+  },
+  [t.EACH]: { argsSchema: a(be), description: o(be) },
+  [t.IF]: { argsSchema: a(Ce), description: o(Ce) }
+}, Ne = vt(_t), Ee = Ne.ComponentNode, kt = Ne.Node, A = Object.fromEntries(
+  Ee.options.map((s) => [s.shape.type.value, s])
+), Oe = e.registry(), Pt = e.registry(), n = t, Dt = [
+  n.INPUT,
+  n.INPUT_GROUP_INPUT,
+  n.INPUT_GROUP_TEXTAREA,
+  n.TEXTAREA,
+  n.IMAGE,
+  n.SEPARATOR,
+  n.CHECKBOX,
+  n.SWITCH,
+  n.OTP,
+  n.SIGNATURE,
+  n.CALENDAR,
+  n.LOADER,
+  n.SKELETON,
+  n.PROGRESS,
+  n.AVATAR
+], xe = [n.TABLE_HEADER, n.TABLE_BODY, n.TABLE_FOOTER], p = [n.CARD, n.CARD_HEADER, n.CARD_FOOTER], m = [n.INPUT_GROUP, n.INPUT_GROUP_ADDON], u = {
+  [n.ACCORDION]: { accepts: [n.ACCORDION_ITEM] },
+  [n.ACCORDION_ITEM]: { accepts: [n.ACCORDION_TRIGGER, n.ACCORDION_CONTENT], parent: [n.ACCORDION] },
+  [n.ACCORDION_TRIGGER]: { parent: [n.ACCORDION_ITEM] },
+  [n.ACCORDION_CONTENT]: { parent: [n.ACCORDION_ITEM] },
+  [n.COLLAPSIBLE_TRIGGER]: { parent: [n.COLLAPSIBLE] },
+  [n.COLLAPSIBLE_CONTENT]: { parent: [n.COLLAPSIBLE] },
+  [n.TABLE]: { accepts: [...xe, n.TABLE_CAPTION] },
+  [n.TABLE_HEADER]: { accepts: [n.TABLE_ROW], parent: [n.TABLE] },
+  [n.TABLE_BODY]: { accepts: [n.TABLE_ROW], parent: [n.TABLE] },
+  [n.TABLE_FOOTER]: { accepts: [n.TABLE_ROW], parent: [n.TABLE] },
+  [n.TABLE_CAPTION]: { parent: [n.TABLE] },
+  [n.TABLE_ROW]: { accepts: [n.TABLE_CELL, n.TABLE_HEAD], parent: xe },
+  [n.TABLE_CELL]: { parent: [n.TABLE_ROW] },
+  [n.TABLE_HEAD]: { parent: [n.TABLE_ROW] },
+  [n.CARD_HEADER]: { parent: [n.CARD] },
+  [n.CARD_CONTENT]: { parent: [n.CARD] },
+  [n.CARD_FOOTER]: { parent: [n.CARD] },
+  [n.CARD_TITLE]: { parent: p },
+  [n.CARD_DESCRIPTION]: { parent: p },
+  [n.CARD_ACTION]: { parent: p },
+  [n.CARD_ICON]: { parent: p },
+  [n.INPUT_GROUP_ADDON]: { parent: [n.INPUT_GROUP] },
+  [n.INPUT_GROUP_TEXT]: { parent: m },
+  [n.INPUT_GROUP_INPUT]: { parent: m },
+  [n.INPUT_GROUP_BUTTON]: { parent: m },
+  [n.INPUT_GROUP_TEXTAREA]: { parent: m },
+  [n.OL]: { accepts: [n.LI] },
+  [n.UL]: { accepts: [n.LI] },
+  [n.LI]: { parent: [n.OL, n.UL] }
+};
+for (const s of Dt) u[s] = { ...u[s], accepts: "none" };
+const ft = {
+  id: { label: "Element ID", group: "Advanced" },
+  className: { label: "Classes", group: "Advanced" },
+  href: { label: "Link URL", group: "Content", placeholder: "https://" },
+  src: { label: "Image URL", group: "Content", placeholder: "https:// or {{binding}}" },
+  alt: { label: "Alt text", group: "Content" },
+  placeholder: { label: "Placeholder", group: "Content" },
+  fallback: { label: "Fallback text", group: "Content" },
+  value: { label: "Bound value", control: "binding", group: "Data" },
+  checked: { label: "Bound value", control: "binding", group: "Data" },
+  selected: { label: "Bound value", control: "binding", group: "Data" },
+  htmlFor: { label: "For input (ID)", group: "Data" },
+  disabled: { label: "Disabled", group: "Data" },
+  required: { label: "Required", group: "Data" },
+  loading: { label: "Loading", group: "Data" },
+  readonly: { label: "Read only", group: "Data" },
+  items: { label: "Repeat over", control: "binding", group: "Data", placeholder: "{{items}}" },
+  index: { label: "Index alias", group: "Data" },
+  key: { label: "Row key", control: "binding", group: "Advanced" },
+  condition: { label: "Show when", control: "binding", group: "Data", placeholder: "{{flag}}" },
+  variant: { label: "Variant", group: "Style" },
+  size: { label: "Size", group: "Style" },
+  raised: { label: "Shadow", group: "Style" },
+  extrude: { label: "Extrude", group: "Style" },
+  rounded: { label: "Corners", group: "Style" },
+  align: { label: "Alignment", group: "Style" },
+  fill: { label: "Colour", group: "Style" },
+  stacked: { label: "Stacked spacing", group: "Style" },
+  animate: { label: "Animate", group: "Style" },
+  buttonVariant: { label: "Button variant", group: "Style" },
+  mode: { label: "Mode", group: "Style" },
+  rows: { label: "Rows", group: "Style" },
+  autosize: { label: "Auto-size", group: "Style" },
+  type: { label: "Button type", group: "Content" },
+  imageType: { label: "Image format", group: "Advanced" },
+  containerClassName: { label: "Container classes", group: "Advanced" },
+  canvasClassname: { label: "Canvas classes", group: "Advanced" },
+  minLength: { label: "Min length", group: "Advanced" },
+  maxLength: { label: "Max length", group: "Advanced" },
+  hideWeekends: { label: "Hide weekends", group: "Advanced" },
+  pins: { label: "Pins", control: "json", group: "Advanced" },
+  zoom: { label: "Zoom", group: "Advanced" },
+  pitch: { label: "Pitch", group: "Advanced" },
+  fixed: { label: "Fixed viewport", group: "Advanced" },
+  allowMultiple: { label: "Allow multiple pins", group: "Advanced" },
+  icon: { label: "Icon", group: "Advanced" },
+  pingIcon: { label: "Ping icon", control: "json", group: "Advanced" },
+  iconProps: { label: "Icon props", control: "json", group: "Advanced" },
+  badge: { label: "Badge", control: "json", group: "Advanced" }
+}, Bt = {
+  [n.EACH]: { as: { label: "Item alias", group: "Data" } },
+  [n.H]: { as: { label: "Render as", group: "Advanced" } },
+  [n.P]: { as: { label: "Render as", group: "Advanced" } },
+  [n.BUTTON]: { icon: { label: "Icon-only size", group: "Style" } }
+};
+function Ut(s) {
+  let l = A[s]?.shape.args;
+  for (; l instanceof e.ZodOptional; ) l = l.unwrap();
+  return l instanceof e.ZodObject ? l : void 0;
+}
+for (const [s, l] of Object.entries(A)) {
+  Oe.add(l, { accepts: "any", ...u[s] });
+  const d = Ut(s)?.shape ?? {};
+  for (const [c, g] of Object.entries(d))
+    Pt.add(g, { ...ft[c], ...Bt[s]?.[c] });
+}
+function Ht(s) {
+  const l = A[s];
+  return l && Oe.get(l) || { accepts: "any" };
+}
+export {
+  Ee as C,
+  A as N,
+  _t as P,
+  kt as a,
+  Ht as b,
+  vt as c,
+  Pt as f,
+  Ut as g,
+  Oe as n
+};
+//# sourceMappingURL=builder.meta-WpXc5VBB.js.map