@pebble-software/bonsai 0.0.8 → 0.1.0

package/dist/lib/registry/json-schema-to-zod.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+/**
+ * Compiles the JSON Schema subset a manifest's `propsSchema` is allowed to use into a
+ * Zod validator (REGISTRY_SPIKE.md, "Registry manifests": "JSON Schema on the wire;
+ * compiled to a Zod validator at load"). Deliberately a subset, not a general JSON
+ * Schema implementation — enough to express prop narrowing (type, enum, required,
+ * string/number bounds), which is the only thing a Case A manifest is allowed to do
+ * to a prop schema in the first place.
+ */
+export type JsonSchema = Record<string, unknown>;
+export interface JsonSchemaToZodOptions {
+    /**
+     * Accept a `"{{expression}}"` binding anywhere a typed value is declared.
+     *
+     * A template author writes `checked: "{{form.agree}}"` and the binding is resolved at
+     * render time, long after validation runs — so a schema saying `{"type":"boolean"}`
+     * rejects a template that would render perfectly. The hand-rolled registry has always
+     * worked around this by declaring `z.union([z.string(), z.boolean()])` by hand on every
+     * affected prop. This is that convention made available to manifests whose schemas were
+     * machine-derived from component sources and so cannot hand-write it.
+     *
+     * Opt-in rather than automatic: `bonsai.generated.json` doubles as an LLM tool
+     * definition, and a prop that reads "boolean" there is worth keeping precise.
+     *
+     * Narrower than the hand-rolled convention on purpose — only binding-*shaped* strings
+     * are admitted, not every string. `{"type":"string","minLength":1}` therefore still
+     * rejects `""`, and an `enum` still rejects a value outside it, both of which a blanket
+     * `z.string()` union would silently discard.
+     */
+    allowBindings?: boolean;
+}
+export declare function jsonSchemaToZod(schema: JsonSchema, options?: JsonSchemaToZodOptions): z.ZodType<unknown>;

package/dist/lib/registry/manifest-schema.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+export declare const ManifestControlledSchema: z.ZodObject<{
+    valueProp: z.ZodString;
+    changeProp: z.ZodString;
+    extract: z.ZodString;
+}, z.core.$strict>;
+export declare const ManifestComponentSchema: z.ZodObject<{
+    name: z.ZodString;
+    canonicalName: z.ZodOptional<z.ZodString>;
+    entry: z.ZodString;
+    propsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        children: "children";
+        bindings: "bindings";
+        events: "events";
+        formField: "formField";
+        ssr: "ssr";
+        pdf: "pdf";
+    }>>>;
+    controlled: z.ZodOptional<z.ZodObject<{
+        valueProp: z.ZodString;
+        changeProp: z.ZodString;
+        extract: z.ZodString;
+    }, z.core.$strict>>;
+    css: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const RegistryManifestSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    namespace: z.ZodOptional<z.ZodString>;
+    version: z.ZodString;
+    engine: z.ZodObject<{
+        name: z.ZodLiteral<"bonsai">;
+        api: z.ZodString;
+    }, z.core.$strict>;
+    components: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        canonicalName: z.ZodOptional<z.ZodString>;
+        entry: z.ZodString;
+        propsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            children: "children";
+            bindings: "bindings";
+            events: "events";
+            formField: "formField";
+            ssr: "ssr";
+            pdf: "pdf";
+        }>>>;
+        controlled: z.ZodOptional<z.ZodObject<{
+            valueProp: z.ZodString;
+            changeProp: z.ZodString;
+            extract: z.ZodString;
+        }, z.core.$strict>>;
+        css: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    integrity: z.ZodOptional<z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        manifestHash: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RegistryManifest = z.infer<typeof RegistryManifestSchema>;
+export type ManifestComponent = z.infer<typeof ManifestComponentSchema>;

package/dist/lib/registry/manifest.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { RegistryManifest } from './manifest-schema.js';
+import { BonsaiRegistry } from './types.js';
+export type { RegistryManifest, ManifestComponent } from './manifest-schema.js';
+export { RegistryManifestSchema } from './manifest-schema.js';
+export declare const EXTRACTOR_ALLOWLIST: Record<string, (eventOrValue: unknown) => unknown>;
+export declare class ManifestLoadError extends Error {
+    constructor(message: string);
+}
+export declare function composePropsSchema(baseSchema: z.ZodType<unknown> | undefined, tenantSchema: z.ZodType<unknown> | undefined): z.ZodType<unknown> | undefined;
+export declare function computeManifestHash(raw: string): Promise<string>;
+export interface ResolveManifestOptions {
+    base: BonsaiRegistry;
+    engineApi?: string;
+    maxComponents?: number;
+    maxManifestBytes?: number;
+    rawManifestSize?: number;
+    manifestHash?: string;
+}
+export declare function resolveManifest(manifest: RegistryManifest, options: ResolveManifestOptions): BonsaiRegistry;
+export interface LoadManifestOptions extends ResolveManifestOptions {
+    allowedOrigins?: string[];
+    fetchImpl?: typeof fetch;
+}
+export declare function clearManifestCache(): void;
+export declare function loadRegistryManifest(source: RegistryManifest | string, options: LoadManifestOptions): Promise<BonsaiRegistry>;

package/dist/lib/registry/merge-generated.d.ts

@@ -0,0 +1,7 @@
+import { JsonSchema } from './json-schema-to-zod.js';
+export type ObjectPropsSchema = {
+    type?: "object";
+    properties: Record<string, JsonSchema>;
+    required?: string[];
+};
+export declare function mergeGeneratedWithOverrides(generated: ObjectPropsSchema | undefined, overrides: Partial<ObjectPropsSchema> | undefined): ObjectPropsSchema;

package/dist/lib/registry/pebble-registry.d.ts

@@ -0,0 +1 @@
+export declare const pebbleRegistry: import('./types.js').BonsaiRegistry;

package/dist/lib/registry/types.d.ts

@@ -0,0 +1,29 @@
+import { ComponentType } from 'react';
+import { ZodType } from 'zod';
+export type ComponentCapability = "children" | "bindings" | "events" | "formField" | "ssr" | "pdf";
+export interface ControlledFieldSpec {
+    valueProp: string;
+    changeProp: string;
+    extract: (eventOrValue: unknown) => unknown;
+}
+export interface ComponentDefinition {
+    component: ComponentType<any> | string;
+    propsSchema?: ZodType<any>;
+    capabilities?: ComponentCapability[];
+    controlled?: ControlledFieldSpec | Record<string, ControlledFieldSpec>;
+    assets?: {
+        css?: string[];
+        fonts?: string[];
+    };
+}
+export type RegistryFallback = "error" | "div" | ComponentType<any>;
+export interface BonsaiRegistry {
+    id: string;
+    version: string;
+    namespace?: string;
+    manifestHash?: string;
+    components: Record<string, ComponentDefinition>;
+    fallback?: RegistryFallback;
+}
+export declare function defineComponent(def: ComponentDefinition): ComponentDefinition;
+export declare function defineBonsaiRegistry(registry: BonsaiRegistry): BonsaiRegistry;

package/dist/lib/registry/validate.d.ts

@@ -0,0 +1,18 @@
+import { Config } from '../../types.js';
+import { RegistryIdentity } from './identity.js';
+import { BonsaiRegistry } from './types.js';
+export interface RegistryValidationError {
+    path: string;
+    message: string;
+    componentType?: string;
+}
+export interface RegistryValidationResult {
+    valid: boolean;
+    errors: RegistryValidationError[];
+    warnings: string[];
+}
+export interface ValidateTemplateOptions {
+    mode?: "web" | "pdf";
+    pin?: RegistryIdentity;
+}
+export declare function validateTemplate(template: Config, registry: BonsaiRegistry, options?: ValidateTemplateOptions): RegistryValidationResult;

package/dist/lib/renderer/compile-template.d.ts

@@ -0,0 +1,70 @@
+import { Config } from '../../types.js';
+import { CompiledExpression } from '../ast/index.js';
+/**
+ * Ahead-of-render metadata for one template node.
+ *
+ * Everything here is *scope-independent*: it is a pure function of the template
+ * node itself, so it survives being reused by every `each` row, every renderer
+ * instance and both render paths. Anything that depends on a row's `scope` /
+ * `indexScope`, on the live store, or on the `BonsaiRegistry` read from React
+ * context deliberately stays in the render path.
+ */
+export interface CompiledNode {
+    /** The raw template node this was compiled from. */
+    source: Config;
+    /** True when the node is a bare string leaf. */
+    isText: boolean;
+    /** Element type *string* only — the registry lookup stays at render time. */
+    type: string;
+    isEach: boolean;
+    isIf: boolean;
+    isImage: boolean;
+    /** Variables the node's own bindings read, pre-split into path segments. */
+    dynamicKeys: CompiledKey[];
+    /** Arg names whose value is a `{{...}}` expression, so static props skip evaluation. */
+    dynamicArgs: Set<string>;
+    /**
+     * Arg name -> unresolved store path, only for args whose expression is a plain
+     * path (`{{user.name}}`, `{{rows[0].x}}`). Formulas (`{{a + b}}`, `{{xs.filter(...)}}`)
+     * have no path to write back to, so they're left out.
+     */
+    argPaths: Record<string, string>;
+    /** Parsed expressions keyed by arg name; `text` for a string leaf. */
+    expressions: Record<string, CompiledExpression>;
+    text: CompiledExpression | null;
+    /** True when the node has no bindings and is not a control node, so it can render as a memoised static subtree. */
+    isStatic: boolean;
+    each: CompiledEach | null;
+    children: CompiledNode[];
+}
+/** A dynamic key with the path-splitting work already done. */
+export interface CompiledKey {
+    /** The key exactly as `extractVariables` produced it, e.g. `applicant.name`. */
+    key: string;
+    /** `key` split and unwrapped, e.g. `["rows", "0", "label"]`. */
+    segments: string[];
+    /** `numericNext[i]` is true when `segments[i + 1]` is an array index. */
+    numericNext: boolean[];
+}
+export interface CompiledEach {
+    as: string;
+    indexAlias: string | undefined;
+    keyExpr: any;
+    /**
+     * The unresolved store path the array lives at (`""` for a computed items
+     * expression). Resolving it against a row's `scope` stays at render time.
+     */
+    rawItemsPath: string;
+}
+export interface CompiledTemplate {
+    root: CompiledNode;
+    source: Config;
+}
+export declare function splitPathSegments(path: string): string[];
+export declare function unwrapSegment(seg: string): string;
+/**
+ * Compiles a template once and caches it by object identity, so mounting the
+ * same template in N renderer instances does the work once. Both `RenderTree`
+ * (SSR) and `RenderTreeClient` (client) consume the result.
+ */
+export declare function compileTemplate(template: Config): CompiledTemplate;

package/dist/lib/ui/registry.d.ts

@@ -0,0 +1,19 @@
+import { ComponentRegistry, ControlledInput, ControlledInputEntry, ControlledInputRegistry } from '../../renderer/core-registry.js';
+/**
+ * The full, batteries-included registry: every core component plus the heavy
+ * opt-in presets (calendar, signature). Importing this module transitively
+ * pulls in react-day-picker and react-signature-canvas — use
+ * `renderer/core-registry` if you want to stay lightweight.
+ *
+ * Typed with `ComponentRegistry`/`ControlledInputRegistry` (both
+ * `Record<string, ...>`) rather than `Record<COMPONENT[number], ...>` from
+ * `@bonsai/constants` — that package is workspace-only and unpublished, and
+ * referencing its types here would bake an escaping import path into this
+ * file's emitted declaration, the same class of bug fixed for `Config` in
+ * `src/types.ts`. (`COMPONENT[number]`, a numeric index into a union of
+ * string-literal enum members, was already widening to plain `string` here —
+ * so `ComponentRegistry`/`ControlledInputRegistry` lose nothing.)
+ */
+export declare const componentMap: ComponentRegistry;
+export declare const controlledInputMap: ControlledInputRegistry;
+export type { ControlledInput, ControlledInputEntry };

package/dist/lib/utils.d.ts

@@ -0,0 +1,3 @@
+import { ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;
+export declare function colorHash(text: string): string;

package/dist/presets/calendar.js

@@ -0,0 +1,373 @@
+import { c as a, b, B as _, C as h } from "../chunks/button-CSLrIvsS.js";
+import { jsxs as p, jsx as t } from "react/jsx-runtime";
+import * as x from "react";
+import { getDefaultClassNames as S, DayPicker as z } from "react-day-picker";
+import { IconSelector as C, IconCheck as k, IconChevronUp as D, IconChevronDown as v, IconChevronLeft as I, IconChevronRight as j } from "@tabler/icons-react";
+import { Select as s } from "@base-ui/react/select";
+const y = s.Root;
+y.displayName = "Select";
+function P({ className: n, ...e }) {
+  return /* @__PURE__ */ t(
+    s.Value,
+    {
+      "data-slot": "select-value",
+      className: a(
+        "flex flex-1 text-left",
+        "group/select-trigger:line-clamp-1 group/select-trigger:items-center data-placeholder:text-subtle font-base",
+        n
+      ),
+      ...e
+    }
+  );
+}
+function L({
+  className: n,
+  size: e = "lg",
+  variant: i = "outline",
+  raised: c,
+  extrude: m,
+  children: f,
+  ...r
+}) {
+  return /* @__PURE__ */ p(
+    s.Trigger,
+    {
+      "data-slot": "select-trigger",
+      "data-size": e,
+      "aria-label": r["aria-label"] ?? "select-trigger",
+      className: a(
+        b({ size: e, variant: i, raised: c, extrude: m }),
+        "group/select-trigger neo-base neo-input-focus disabled:opacity-50 [&_svg]:shrink-0 w-full",
+        n
+      ),
+      ...r,
+      children: [
+        f,
+        /* @__PURE__ */ t(
+          s.Icon,
+          {
+            className: "flex items-center justify-center",
+            render: /* @__PURE__ */ t(
+              C,
+              {
+                "data-slot": "select-selector",
+                className: "text-muted size-4 pointer-events-none"
+              }
+            )
+          }
+        )
+      ]
+    }
+  );
+}
+function R({
+  className: n,
+  children: e,
+  side: i = "bottom",
+  sideOffset: c = 4,
+  align: m = "center",
+  alignOffset: f = 0,
+  alignItemWithTrigger: r = !0,
+  ...g
+}) {
+  return /* @__PURE__ */ t(s.Portal, { children: /* @__PURE__ */ t(
+    s.Positioner,
+    {
+      side: i,
+      sideOffset: c,
+      align: m,
+      alignOffset: f,
+      alignItemWithTrigger: r,
+      className: "isolate z-50",
+      children: /* @__PURE__ */ p(
+        s.Popup,
+        {
+          "data-slot": "select-content",
+          className: a(
+            "neo-base neo-focus relative isolate bg-surface text-foreground rounded-base shadow-md border-2 z-50 duration-100",
+            "max-h-(--available-height) w-(--anchor-width) min-w-36",
+            "origin-(--transform-origin) overflow-x-hidden overflow-y-auto",
+            "data-open:animate-in data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95",
+            "data-closed:animate-out data-closed:fade-out-0",
+            "data-[side=top]:slide-in-from-bottom-2",
+            "data-[side=bottom]:slide-in-from-top-2",
+            "data-[side=left]:slide-in-from-right-2",
+            "data-[side=right]:slide-in-from-left-2",
+            n
+          ),
+          ...g,
+          children: [
+            /* @__PURE__ */ t(B, {}),
+            /* @__PURE__ */ t(s.List, { className: "flex flex-col gap-0.5 p-0.5", children: e }),
+            /* @__PURE__ */ t(E, {})
+          ]
+        }
+      )
+    }
+  ) });
+}
+function A({
+  className: n,
+  children: e,
+  ...i
+}) {
+  return /* @__PURE__ */ p(
+    s.Item,
+    {
+      "data-slot": "select-item",
+      className: a(
+        "neo-base flex items-center gap-2 py-1.5 pr-8 pl-2 relative w-full cursor-pointer select-none",
+        "border-2 border-transparent hover:border-border focus-visible:border-border outline-hidden rounded-base text-sm",
+        "*:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2",
+        "data-disabled:pointer-events-none data-disabled:opacity-50",
+        "[&_svg]:pointer-events-none [&_svg]:shrink-0",
+        n
+      ),
+      ...i,
+      children: [
+        /* @__PURE__ */ t(s.ItemText, { className: "flex flex-1 gap-2 shrink-0 whitespace-nowrap", children: e }),
+        /* @__PURE__ */ t(
+          s.ItemIndicator,
+          {
+            render: /* @__PURE__ */ t("span", { className: "pointer-events-none absolute right-2 flex size-4 items-center justify-center" }),
+            children: /* @__PURE__ */ t(k, { className: "pointer-events-none" })
+          }
+        )
+      ]
+    }
+  );
+}
+function B({
+  className: n,
+  ...e
+}) {
+  return /* @__PURE__ */ t(
+    s.ScrollUpArrow,
+    {
+      "data-slot": "select-scroll-up-button",
+      className: a(
+        "bg-surface z-10 flex cursor-default items-center justify-center py-1 top-0 w-full",
+        n
+      ),
+      ...e,
+      children: /* @__PURE__ */ t(D, {})
+    }
+  );
+}
+function E({
+  className: n,
+  ...e
+}) {
+  return /* @__PURE__ */ t(
+    s.ScrollDownArrow,
+    {
+      "data-slot": "select-scroll-down-button",
+      className: a(
+        "bg-surface z-10 flex cursor-default items-center justify-center py-1 bottom-0 w-full",
+        n
+      ),
+      ...e,
+      children: /* @__PURE__ */ t(v, {})
+    }
+  );
+}
+function T({
+  className: n,
+  classNames: e,
+  showOutsideDays: i = !0,
+  captionLayout: c = "label",
+  hideWeekdays: m = !1,
+  buttonVariant: f = "outline",
+  hideWeekends: r,
+  formatters: g,
+  components: w,
+  ...N
+}) {
+  const o = S();
+  return /* @__PURE__ */ t(
+    z,
+    {
+      showOutsideDays: i,
+      className: a(
+        "p-3 bg-surface group/calendar [--cell-size:--spacing(8)]",
+        "in-data-[slot=card-content]:bg-transparent",
+        "in-data-[slot=popover-content]:bg-transparent",
+        n
+      ),
+      captionLayout: c,
+      formatters: {
+        formatCaption: (l) => l.toLocaleString("default", { month: "short", year: "numeric" }),
+        formatMonthDropdown: (l) => l.toLocaleString("default", { month: "short" }),
+        ...g
+      },
+      classNames: {
+        root: a("w-fit", o.root),
+        nav: a(
+          "flex items-center gap-1 w-full absolute top-0 inset-x-0 justify-between",
+          o.nav
+        ),
+        button_previous: a(
+          b({ variant: f, icon: "sm" }),
+          "aria-disabled:opacity-50 aria-disabled:translate-[0px] aria-disabled:shadow-none aria-disabled:pointer-events-none",
+          o.button_previous
+        ),
+        button_next: a(
+          b({ variant: f, icon: "sm" }),
+          "aria-disabled:opacity-50 aria-disabled:translate-[0px] aria-disabled:shadow-none aria-disabled:pointer-events-none",
+          o.button_next
+        ),
+        caption_label: a("select-none", o.caption_label),
+        months: a(
+          "flex gap-4 flex-col md:flex-row relative",
+          o.months
+        ),
+        month: a(
+          "flex flex-col w-full gap-4 *:first:*:h-(--cell-size) *:first:*:flex *:first:*:items-center *:first:*:justify-center *:first:**:font-medium *:first:**:font-heading *:first:**:text-base",
+          o.month
+        ),
+        table: "w-full border-collapse",
+        weekdays: a("flex", o.weekdays),
+        weekday: a(
+          m ? "hidden" : "text-sm font-normal font-heading text-muted text-center select-none flex-1",
+          o.weekday
+        ),
+        week_number: a(
+          "text-sm font-normal font-heading text-muted text-center select-none flex size-(--cell-size) items-center justify-center my-auto",
+          o.week_number
+        ),
+        week_number_header: a(
+          "select-none w-(--cell-size)",
+          o.week_number_header
+        ),
+        week: a("flex w-full", o.week),
+        day: a(
+          "relative text-center group/day select-none transition-[width,padding,margin] duration-200",
+          o.day
+        ),
+        day_button: a("m-1", o.day_button),
+        today: a(
+          "*:data-[slot=calendar-day-button]:font-semibold *:data-[slot=calendar-day-button]:text-lg",
+          o.today
+        ),
+        outside: a(
+          "text-muted aria-selected:text-foreground opacity-50 hover:opacity-100 aria-selected:opacity-100 aria-selected:*:data-[slot=calendar-day-button]:bg-main-secondary hover:*:data-[slot=calendar-day-button]:bg-surface *:data-[slot=calendar-day-button]:bg-foreground/20",
+          o.outside
+        ),
+        ...e
+      },
+      components: {
+        Root: ({ className: l, rootRef: d, ...u }) => /* @__PURE__ */ t(
+          "div",
+          {
+            "data-slot": "calendar",
+            ref: d,
+            className: a(l),
+            ...u
+          }
+        ),
+        Chevron: ({ className: l, orientation: d, ...u }) => d === "left" ? /* @__PURE__ */ t(I, { className: a("size-4", l), ...u }) : d === "right" ? /* @__PURE__ */ t(
+          j,
+          {
+            className: a("size-4", l),
+            ...u
+          }
+        ) : /* @__PURE__ */ t(v, { className: a("size-4", l), ...u }),
+        Weekday: ({ children: l, ...d }) => {
+          const u = d["aria-label"] === "Saturday" || d["aria-label"] === "Sunday";
+          return r && u ? /* @__PURE__ */ t("td", { hidden: !0 }) : /* @__PURE__ */ t("td", { ...d, children: l });
+        },
+        Day: ({ children: l, ...d }) => {
+          const u = new Date(d.day.date).getDay();
+          return r && (u === 0 || u === 6) ? /* @__PURE__ */ t("td", { hidden: !0 }) : d.modifiers.hidden ? /* @__PURE__ */ t("td", { className: "all-unset size-(--cell-size) m-1 bg-foreground opacity-20 rounded-base" }) : /* @__PURE__ */ t("td", { ...d, children: l });
+        },
+        Dropdown: V,
+        DayButton: U,
+        ...w
+      },
+      ...N
+    }
+  );
+}
+function U({
+  day: n,
+  modifiers: e,
+  ...i
+}) {
+  const c = x.useRef(null);
+  return x.useEffect(() => {
+    e.focused && c.current?.focus();
+  }, [e.focused]), /* @__PURE__ */ t(
+    _,
+    {
+      "data-slot": "calendar-day-button",
+      "data-day": n.date.toLocaleDateString(),
+      "data-selected-single": e.selected && !e.range_start && !e.range_end && !e.range_middle,
+      "data-range-start": e.range_start,
+      "data-range-end": e.range_end,
+      "data-range-middle": e.range_middle,
+      "aria-label": n.date.toDateString(),
+      raised: e.range_start || e.range_end ? "md" : e.range_middle ? "xs" : "sm",
+      variant: e.selected ? "default" : "outline",
+      extrude: e.selected ? null : "xs",
+      disabled: e.disabled,
+      icon: "sm",
+      ...i
+    }
+  );
+}
+function V(n) {
+  const { options: e, onChange: i, value: c } = n, m = e?.find((r) => r.value === c), f = (r) => {
+    i?.({
+      target: { value: r }
+    });
+  };
+  return /* @__PURE__ */ p(
+    y,
+    {
+      value: c?.toString(),
+      onValueChange: (r) => f(r),
+      children: [
+        /* @__PURE__ */ t(
+          L,
+          {
+            variant: "ghost",
+            raised: null,
+            extrude: null,
+            className: "w-fit mx-1",
+            size: "sm",
+            children: /* @__PURE__ */ t(P, { children: m?.label })
+          }
+        ),
+        /* @__PURE__ */ t(R, { className: "bg-transparent border-0 w-30 shadow-none", children: /* @__PURE__ */ t("div", { className: "p-2", children: /* @__PURE__ */ t("div", { className: "flex flex-col items-center bg-foreground shadow-xs rounded-base", children: e?.map((r) => /* @__PURE__ */ t(
+          A,
+          {
+            className: a(
+              b({ extrude: "md" }),
+              "not-last:rounded-b-none not-first:rounded-t-none border-2 not-last:border-b-0 hover:border-2 hover:z-2 z-1 duration-200"
+            ),
+            value: r.value.toString(),
+            children: r.label
+          },
+          r.value
+        )) }) }) })
+      ]
+    }
+  );
+}
+const G = {
+  components: {
+    [h.CALENDAR]: T
+  },
+  controlledInputs: {
+    [h.CALENDAR]: {
+      valueProp: "selected",
+      changeProp: "onSelect",
+      extractor: (n) => n
+    }
+  }
+};
+export {
+  T as Calendar,
+  G as calendarPreset
+};
+//# sourceMappingURL=calendar.js.map