@pebble-software/bonsai 0.0.3 → 0.0.5

package/dist/index.d.ts

@@ -1,4 +1,316 @@
-export { Bonsai, useUpdateData } from './components/core/bonsai';
-export { componentMap, controlledInputMap } from './lib/ui/registry';
-export type { Config } from '../../../library/schemas/src/index.ts';
-export type { SignatureProps } from './components/ui/signature-pad';
+import { ComponentType } from 'react';
+import { JSX } from 'react';
+import { z } from 'zod';
+import { ZodType } from 'zod';
+
+export declare function assertNoFailingDrift(issues: DriftIssue[]): void;
+
+export declare function Bonsai(props: BonsaiProps): JSX.Element;
+
+declare interface BonsaiProps {
+    captureUrl: string;
+    expiry: string;
+    template: Config;
+    data?: any;
+    status?: "pending" | "captured" | "completed" | "error" | "revoked";
+    render?: "web" | "pdf" | "preview";
+    registry?: BonsaiRegistry;
+}
+
+export declare interface BonsaiRegistry {
+    id: string;
+    version: string;
+    namespace?: string;
+    manifestHash?: string;
+    components: Record<string, ComponentDefinition>;
+    fallback?: RegistryFallback;
+}
+
+export declare function checkArtifactDrift(input: DriftCheckInput): DriftIssue[];
+
+export declare function clearManifestCache(): void;
+
+declare enum COMPONENT {
+    A = "a",
+    P = "p",
+    H = "h",
+    OL = "ol",
+    UL = "ul",
+    LI = "li",
+    MAP = "map",
+    DIV = "div",
+    SPAN = "span",
+    ACCORDION = "accordion",
+    ACCORDION_ITEM = "accordion-item",
+    ACCORDION_TRIGGER = "accordion-trigger",
+    ACCORDION_CONTENT = "accordion-content",
+    ALERT = "alert",
+    AVATAR = "avatar",
+    BADGE = "badge",
+    BUTTON = "button",
+    CARD = "card",
+    CARD_HEADER = "card-header",
+    CARD_TITLE = "card-title",
+    CARD_DESCRIPTION = "card-description",
+    CARD_CONTENT = "card-content",
+    CARD_FOOTER = "card-footer",
+    CARD_ACTION = "card-action",
+    CARD_ICON = "card-icon",
+    CALENDAR = "calendar",
+    CHECKBOX = "checkbox",
+    COLLAPSIBLE = "collapsible",
+    COLLAPSIBLE_TRIGGER = "collapsible-trigger",
+    COLLAPSIBLE_CONTENT = "collapsible-content",
+    IMAGE = "image",
+    OTP = "otp",
+    INPUT = "input",
+    INPUT_GROUP = "input-group",
+    INPUT_GROUP_TEXT = "input-group-text",
+    INPUT_GROUP_ADDON = "input-group-addon",
+    INPUT_GROUP_BUTTON = "input-group-button",
+    INPUT_GROUP_INPUT = "input-group-input",
+    INPUT_GROUP_TEXTAREA = "input-group-textarea",
+    LABEL = "label",
+    LOADER = "loader",
+    PROGRESS = "progress",
+    SEPARATOR = "separator",
+    SKELETON = "skeleton",
+    SWITCH = "switch",
+    TABLE = "table",
+    TABLE_HEADER = "table-header",
+    TABLE_BODY = "table-body",
+    TABLE_FOOTER = "table-footer",
+    TABLE_HEAD = "table-head",
+    TABLE_ROW = "table-row",
+    TABLE_CELL = "table-cell",
+    TABLE_CAPTION = "table-caption",
+    TEXTAREA = "textarea",
+    SIGNATURE = "signature",
+    EACH = "each",
+    IF = "if",
+}
+
+export declare type ComponentCapability = "children" | "bindings" | "events" | "formField" | "ssr" | "pdf";
+
+export declare interface ComponentDefinition {
+    component: ComponentType<any> | string;
+    propsSchema?: ZodType<any>;
+    capabilities?: ComponentCapability[];
+    controlled?: ControlledFieldSpec | Record<string, ControlledFieldSpec>;
+    assets?: {
+        css?: string[];
+        fonts?: string[];
+    };
+}
+
+export declare const componentMap: Record<COMPONENT[number], any>;
+
+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 declare const Config = pebbleTemplateSchema.Node;
+
+export declare type Config = z.infer<typeof pebbleTemplateSchema.Node>;
+
+export declare interface ControlledFieldSpec {
+    valueProp: string;
+    changeProp: string;
+    extract: (eventOrValue: unknown) => unknown;
+}
+
+declare interface ControlledInput {
+    valueProp: string;
+    changeProp: string;
+    extractor: (eventOrValue: any) => any;
+}
+
+export declare const controlledInputMap: Record<COMPONENT[number], Record<string, ControlledInput> | ControlledInput>;
+
+export declare function defineBonsaiRegistry(registry: BonsaiRegistry): BonsaiRegistry;
+
+export declare function defineComponent(def: ComponentDefinition): ComponentDefinition;
+
+export declare interface DriftCheckInput {
+    artifactRegistries: RegistrySource[];
+    configRegistries: RegistrySource[];
+    artifactBaseUiVersion: string;
+    installedBaseUiVersion: string;
+}
+
+export declare interface DriftIssue {
+    check: "stale-artifact" | "baseui-drift";
+    level: "warn" | "fail";
+    message: string;
+}
+
+export declare const EXTRACTOR_ALLOWLIST: Record<string, (eventOrValue: unknown) => unknown>;
+
+/**
+ * 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 declare type JsonSchema = Record<string, unknown>;
+
+export declare function jsonSchemaToZod(schema: JsonSchema): z.ZodType<unknown>;
+
+export declare interface LoadManifestOptions extends ResolveManifestOptions {
+    allowedOrigins?: string[];
+    fetchImpl?: typeof fetch;
+}
+
+export declare function loadRegistryManifest(source: RegistryManifest | string, options: LoadManifestOptions): Promise<BonsaiRegistry>;
+
+export declare type ManifestComponent = z.infer<typeof ManifestComponentSchema>;
+
+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";
+        pdf: "pdf";
+        bindings: "bindings";
+        events: "events";
+        formField: "formField";
+        ssr: "ssr";
+    }>>>;
+    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 class ManifestLoadError extends Error {
+    constructor(message: string);
+}
+
+export declare function mergeGeneratedWithOverrides(generated: ObjectPropsSchema | undefined, overrides: Partial<ObjectPropsSchema> | undefined): ObjectPropsSchema;
+
+export declare interface ObjectPropsSchema {
+    type?: "object";
+    properties: Record<string, JsonSchema>;
+    required?: string[];
+}
+
+export declare const pebbleRegistry: BonsaiRegistry;
+
+declare const pebbleTemplateSchema = createTemplateSchema(PEBBLE_COMPONENT_SCHEMAS);
+
+export declare type PinResolution = {
+    action: "render";
+    reason: "no-pin";
+} | {
+    action: "render";
+    reason: "match";
+} | {
+    action: "render";
+    reason: "version-skew";
+    warning: string;
+} | {
+    action: "fail";
+    reason: "id-mismatch";
+    error: string;
+};
+
+declare type RegistryFallback = "error" | "div" | ComponentType<any>;
+
+export declare interface RegistryIdentity {
+    id: string;
+    version: string;
+    manifestHash?: string;
+}
+
+export declare type RegistryManifest = z.infer<typeof RegistryManifestSchema>;
+
+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";
+            pdf: "pdf";
+            bindings: "bindings";
+            events: "events";
+            formField: "formField";
+            ssr: "ssr";
+        }>>>;
+        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 declare interface RegistrySource {
+    url: string;
+    registryHash: string;
+}
+
+export declare interface RegistryValidationError {
+    path: string;
+    message: string;
+    componentType?: string;
+}
+
+export declare interface RegistryValidationResult {
+    valid: boolean;
+    errors: RegistryValidationError[];
+    warnings: string[];
+}
+
+export declare function resolveManifest(manifest: RegistryManifest, options: ResolveManifestOptions): BonsaiRegistry;
+
+export declare interface ResolveManifestOptions {
+    base: BonsaiRegistry;
+    engineApi?: string;
+    maxComponents?: number;
+    maxManifestBytes?: number;
+    rawManifestSize?: number;
+    manifestHash?: string;
+}
+
+export declare function resolveRegistryPin(pin: RegistryIdentity | undefined, registry: Pick<BonsaiRegistry, "id" | "version"> & {
+    manifestHash?: string;
+}): PinResolution;
+
+export declare type SignatureProps = {
+    value?: string | null;
+    onChange?: (value: string | null) => void;
+    canvasClassname?: string;
+    imageType?: "image/png" | "image/jpeg" | "image/webp";
+};
+
+export declare function useUpdateData(): (path: string, value: any) => void;
+
+export declare function validateTemplate(template: Config, registry: BonsaiRegistry, options?: ValidateTemplateOptions): RegistryValidationResult;
+
+export declare interface ValidateTemplateOptions {
+    mode?: "web" | "pdf";
+    pin?: RegistryIdentity;
+}
+
+export { }