@flikk/ui 1.0.0-beta.27 → 1.0.0-beta.29

package/dist/components/generative/GenerativeView.js

@@ -0,0 +1,116 @@
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import React__default from 'react';
+import { Skeleton } from '../core/Skeleton/Skeleton.js';
+import { defaultRegistry, CardShell } from './registry.js';
+import { applyResolvers } from './resolvers.js';
+import { SKELETON_NODE } from './streaming.js';
+import { bindActionProps } from './actions.js';
+
+const placeholderStyle = "rounded-lg border border-dashed border-[var(--color-border-secondary)] " +
+    "bg-[var(--color-surface-sunken)] p-3 text-xs text-[var(--color-text-muted)]";
+/** The model asked for a component we didn't register — render, don't throw. */
+function UnknownNode({ name }) {
+    if (process.env.NODE_ENV !== "production") {
+        console.warn(`[GenerativeView]: unknown component "${name}" — rendering placeholder`);
+    }
+    return (jsxs("div", { role: "note", className: placeholderStyle, children: ["Unknown component \u201C", name, "\u201D"] }));
+}
+/** Streaming placeholder: reserves the target component's footprint until it hydrates. */
+function SkeletonPlaceholder({ props }) {
+    var _a;
+    const height = (_a = props === null || props === void 0 ? void 0 : props.height) !== null && _a !== void 0 ? _a : 80;
+    return jsx(Skeleton, { variant: "rectangle", width: "100%", height: height, className: "rounded-[var(--card-radius)]" });
+}
+/** Per-node error boundary: one bad node never takes down the tree. */
+class NodeBoundary extends React__default.Component {
+    constructor() {
+        super(...arguments);
+        this.state = { failed: false };
+    }
+    static getDerivedStateFromError() {
+        return { failed: true };
+    }
+    componentDidCatch(error) {
+        if (process.env.NODE_ENV !== "production") {
+            console.error(`[GenerativeView]: "${this.props.name}" threw while rendering`, error);
+        }
+    }
+    render() {
+        if (this.state.failed) {
+            return (jsxs("div", { role: "note", className: placeholderStyle, children: ["\u201C", this.props.name, "\u201D failed to render"] }));
+        }
+        return this.props.children;
+    }
+}
+function NodeRenderer({ node, registry, inShell, dispatch, }) {
+    var _a, _b, _c;
+    if (node.component === SKELETON_NODE)
+        return jsx(SkeletonPlaceholder, { props: node.props });
+    const entry = registry.components[node.component];
+    if (!entry)
+        return jsx(UnknownNode, { name: node.component });
+    const hydrated = applyResolvers(((_a = node.props) !== null && _a !== void 0 ? _a : {}), registry.resolvers, { icons: registry.icons, node });
+    const isContainer = entry.kind === "container";
+    if (process.env.NODE_ENV !== "production" && !isContainer && ((_b = node.children) === null || _b === void 0 ? void 0 : _b.length)) {
+        console.warn(`[GenerativeView]: "${node.component}" is not a container — its children are ignored`);
+    }
+    const childInShell = entry.providesShell ? true : inShell;
+    const children = isContainer && ((_c = node.children) === null || _c === void 0 ? void 0 : _c.length)
+        ? node.children.map((child, index) => {
+            var _a;
+            return (jsx(NodeBoundary, { name: child.component, children: jsx(NodeRenderer, { node: child, registry: registry, inShell: childInShell, dispatch: dispatch }) }, (_a = child.id) !== null && _a !== void 0 ? _a : index));
+        })
+        : undefined;
+    // Shell-wrapped leaves: title/subtitle belong to the shell, not the component.
+    let componentProps = hydrated;
+    let shellTitle;
+    let shellSubtitle;
+    if (entry.needsShell) {
+        const { title, subtitle, ...rest } = hydrated;
+        componentProps = rest;
+        shellTitle = title;
+        shellSubtitle = subtitle;
+    }
+    let unboundClick;
+    if (node.actions && dispatch) {
+        const bound = bindActionProps(node, entry.actionProps, componentProps, dispatch);
+        componentProps = bound.props;
+        unboundClick = bound.unboundClick;
+    }
+    const Component = entry.component;
+    let inner;
+    if (entry.render)
+        inner = entry.render(componentProps, children);
+    else if (isContainer)
+        inner = jsx(Component, { ...componentProps, children: children });
+    else
+        inner = jsx(Component, { ...componentProps });
+    const rendered = entry.needsShell && !inShell ? (jsx(CardShell, { title: shellTitle, subtitle: shellSubtitle, children: inner })) : (jsx(Fragment, { children: inner }));
+    if (unboundClick && dispatch) {
+        const descriptor = unboundClick;
+        const fire = () => dispatch(descriptor, {
+            component: node.component,
+            ...(node.id ? { nodeId: node.id } : {}),
+        });
+        return (jsx("div", { role: "button", tabIndex: 0, className: "cursor-pointer rounded-[var(--card-radius)] focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--color-primary)]", onClick: fire, onKeyDown: (e) => {
+                if (e.key === "Enter" || e.key === " ") {
+                    e.preventDefault();
+                    fire();
+                }
+            }, children: rendered }));
+    }
+    return rendered;
+}
+/**
+ * Render a serializable UINode spec with the given registry.
+ * Render-only in P1 — streaming (P3) and action dispatch (P4) layer on top.
+ */
+function GenerativeView({ spec, registry = defaultRegistry, onAction, className, }) {
+    const nodes = Array.isArray(spec) ? spec : [spec];
+    return (jsx("div", { className: className, children: nodes.map((node, index) => {
+            var _a;
+            return (jsx(NodeBoundary, { name: node.component, children: jsx(NodeRenderer, { node: node, registry: registry, inShell: false, dispatch: onAction }) }, (_a = node.id) !== null && _a !== void 0 ? _a : index));
+        }) }));
+}
+
+export { GenerativeView };

package/dist/components/generative/actions.d.ts

@@ -0,0 +1,26 @@
+import { ActionDescriptor, JSONValue, UINode } from "./types";
+/** Serializable context delivered alongside the descriptor. */
+export interface ActionContext {
+    /** The spec component that fired the action. */
+    component: string;
+    /** The node's spec id, when present. */
+    nodeId?: string;
+    /** Serializable callback payload (e.g. the clicked Table row). Never a DOM event. */
+    data?: JSONValue;
+}
+/** Consumer handler: first arg is the EXACT descriptor from the spec. */
+export type ActionHandler = (action: ActionDescriptor, context: ActionContext) => void;
+/** Extract a serializable data argument from a component callback — DOM events are dropped. */
+export declare function extractActionData(arg: unknown): JSONValue | undefined;
+export interface BoundActions {
+    /** Component props with callback props injected for registry-mapped action keys. */
+    props: Record<string, unknown>;
+    /** A `click` action with no native callback mapping — caller wraps the output. */
+    unboundClick?: ActionDescriptor;
+}
+/**
+ * Bind a node's spec actions to component callback props via the registry's
+ * actionProps map. Unmapped `click` actions are returned for generic wrapping;
+ * other unmapped keys are dropped with a dev warning.
+ */
+export declare function bindActionProps(node: UINode, actionProps: Record<string, string> | undefined, componentProps: Record<string, unknown>, dispatch: ActionHandler): BoundActions;

package/dist/components/generative/actions.js

@@ -0,0 +1,51 @@
+/** Extract a serializable data argument from a component callback — DOM events are dropped. */
+function extractActionData(arg) {
+    if (arg === null || arg === undefined)
+        return undefined;
+    const t = typeof arg;
+    if (t === "string" || t === "number" || t === "boolean")
+        return arg;
+    if (t !== "object")
+        return undefined;
+    const obj = arg;
+    if ("nativeEvent" in obj || "preventDefault" in obj || (typeof Event !== "undefined" && arg instanceof Event)) {
+        return undefined; // React SyntheticEvent / DOM event — not serializable
+    }
+    return arg;
+}
+/**
+ * Bind a node's spec actions to component callback props via the registry's
+ * actionProps map. Unmapped `click` actions are returned for generic wrapping;
+ * other unmapped keys are dropped with a dev warning.
+ */
+function bindActionProps(node, actionProps, componentProps, dispatch) {
+    const result = { props: componentProps };
+    if (!node.actions)
+        return result;
+    let next = null;
+    for (const [key, descriptor] of Object.entries(node.actions)) {
+        const propName = actionProps === null || actionProps === void 0 ? void 0 : actionProps[key];
+        if (propName) {
+            next = next !== null && next !== void 0 ? next : { ...componentProps };
+            next[propName] = (...args) => {
+                const data = extractActionData(args[0]);
+                dispatch(descriptor, {
+                    component: node.component,
+                    ...(node.id ? { nodeId: node.id } : {}),
+                    ...(data !== undefined ? { data } : {}),
+                });
+            };
+        }
+        else if (key === "click") {
+            result.unboundClick = descriptor;
+        }
+        else if (process.env.NODE_ENV !== "production") {
+            console.warn(`[GenerativeView]: action "${key}" is not supported by "${node.component}" — ignored`);
+        }
+    }
+    if (next)
+        result.props = next;
+    return result;
+}
+
+export { bindActionProps, extractActionData };

package/dist/components/generative/index.d.ts

@@ -0,0 +1,11 @@
+export { GenerativeView, type GenerativeViewProps } from "./GenerativeView";
+export { createRegistry, defaultRegistry, CardShell, type GenerativeRegistry, type RegistryEntry, type CreateRegistryOptions, } from "./registry";
+export { DEFAULT_ICONS, DEFAULT_STATUS_COLORS, defaultResolvers, iconPropsResolver, tableColumnsResolver, applyResolvers, resolveIcon, type IconMap, type PropResolver, type ResolverContext, } from "./resolvers";
+export type { UINode, UISpec, ActionDescriptor, JSONValue } from "./types";
+export { validate, type ValidateOptions, type ValidateResult, type ValidationIssue } from "./validate";
+export { parsePartialJSON, parseStreamingSpec, isJSONComplete, SKELETON_NODE, SKELETON_PRESETS, type StreamingSpecResult, type ParseStreamingSpecOptions, } from "./streaming";
+export { useGenerativeStream, type UseGenerativeStreamOptions, type UseGenerativeStreamReturn } from "./useGenerativeStream";
+export { bindActionProps, extractActionData, type ActionContext, type ActionHandler, type BoundActions } from "./actions";
+export { buildToolDefinition, GENERATIVE_TOOL, type GenerativeToolDefinition } from "./tools";
+export { GENERATIVE_SCHEMA } from "./schema.generated";
+export type { GenerativeSchemaDoc, ComponentSchema, SchemaProp, SchemaPropKind } from "./schemaTypes";

package/dist/components/generative/index.js

@@ -0,0 +1,9 @@
+export { GenerativeView } from './GenerativeView.js';
+export { CardShell, createRegistry, defaultRegistry } from './registry.js';
+export { DEFAULT_ICONS, DEFAULT_STATUS_COLORS, applyResolvers, defaultResolvers, iconPropsResolver, resolveIcon, tableColumnsResolver } from './resolvers.js';
+export { validate } from './validate.js';
+export { SKELETON_NODE, SKELETON_PRESETS, isJSONComplete, parsePartialJSON, parseStreamingSpec } from './streaming.js';
+export { useGenerativeStream } from './useGenerativeStream.js';
+export { bindActionProps, extractActionData } from './actions.js';
+export { GENERATIVE_TOOL, buildToolDefinition } from './tools.js';
+export { GENERATIVE_SCHEMA } from './schema.generated.js';

package/dist/components/generative/registry.d.ts

@@ -0,0 +1,43 @@
+import React from "react";
+import { IconMap, PropResolver } from "./resolvers";
+export interface RegistryEntry {
+    component: React.ComponentType<Record<string, unknown>>;
+    /** Containers render `children` recursively; leaves ignore them. @default "leaf" */
+    kind?: "leaf" | "container";
+    /** Panel-less components get an automatic Card shell when not already inside one. */
+    needsShell?: boolean;
+    /** Containers that ARE a shell (Card) suppress needsShell in their subtree. */
+    providesShell?: boolean;
+    /** Escape hatch: fully custom element creation (charts, Table, Card). */
+    render?: (props: Record<string, unknown>, children?: React.ReactNode) => React.ReactNode;
+    /** Map spec action keys to component callback props, e.g. { click: "onClick" }. */
+    actionProps?: Record<string, string>;
+}
+export interface GenerativeRegistry {
+    components: Record<string, RegistryEntry>;
+    icons: IconMap;
+    resolvers: PropResolver[];
+}
+export interface CreateRegistryOptions {
+    /** Merged OVER the default component set; pass `{ Name: null }` to remove one. */
+    components?: Record<string, RegistryEntry | null>;
+    /** Merged over DEFAULT_ICONS. */
+    icons?: IconMap;
+    /** REPLACES defaultResolvers when provided (compose manually to extend). */
+    resolvers?: PropResolver[];
+}
+/**
+ * Card shell used by the automatic `needsShell` wrap (KPI, charts).
+ * Card now carries `title`/`subtitle` natively (slot-props), so this is a thin
+ * adapter over those props — no longer a parallel re-implementation of the
+ * Card.Header/Title/Body structure.
+ */
+export declare function CardShell({ title, subtitle, className, children, }: {
+    title?: React.ReactNode;
+    subtitle?: React.ReactNode;
+    className?: string;
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function createRegistry(options?: CreateRegistryOptions): GenerativeRegistry;
+/** The default generative-safe registry (curation expands in P5). */
+export declare const defaultRegistry: GenerativeRegistry;

package/dist/components/generative/registry.js

@@ -0,0 +1,114 @@
+import { jsx } from 'react/jsx-runtime';
+import { Alert } from '../core/Alert/Alert.js';
+import { Avatar } from '../core/Avatar/Avatar.js';
+import { Badge } from '../core/Badge/Badge.js';
+import { Button } from '../core/Button/Button.js';
+import 'react';
+import { Card } from '../core/Card/Card.js';
+import { Progress } from '../core/Progress/Progress.js';
+import { Separator } from '../core/Separator/Separator.js';
+import { Grid } from '../layout/Grid/Grid.js';
+import { Stack } from '../layout/Stack/Stack.js';
+import { Section } from '../layout/Section/Section.js';
+import { cn } from '../../utils/cn.js';
+import { defaultResolvers, DEFAULT_ICONS } from './resolvers.js';
+import { DonutChart } from '../charts/DonutChart/DonutChart.js';
+import { Feed } from '../data-display/Feed/Feed.js';
+import { DescriptionList } from '../data-display/DescriptionList/DescriptionList.js';
+import { Timeline } from '../data-display/Timeline/Timeline.js';
+import { Table } from '../data-display/Table/index.js';
+import { KPI } from '../data-display/KPI/KPI.js';
+import { Metric } from '../data-display/Metric/Metric.js';
+import { ChartContainer } from '../charts/ChartContainer.js';
+import { ComboChart } from '../charts/ComboChart/ComboChart.js';
+import { StackedBarChart } from '../charts/StackedBarChart/StackedBarChart.js';
+import { LineChart } from '../charts/LineChart/LineChart.js';
+import { BarChart } from '../charts/BarChart/BarChart.js';
+import { AreaChart } from '../charts/AreaChart/AreaChart.js';
+
+/** One source of truth for chart height so side-by-side charts always match. */
+const CHART_HEIGHT = 200;
+/** Erase a component's specific prop types at the untyped-JSON spec boundary. */
+const loose = (component) => component;
+const LooseTable = loose(Table);
+const LooseDonutChart = loose(DonutChart);
+const LooseCard = loose(Card);
+/**
+ * Card shell used by the automatic `needsShell` wrap (KPI, charts).
+ * Card now carries `title`/`subtitle` natively (slot-props), so this is a thin
+ * adapter over those props — no longer a parallel re-implementation of the
+ * Card.Header/Title/Body structure.
+ */
+function CardShell({ title, subtitle, className, children, }) {
+    return (jsx(Card, { title: title, subtitle: subtitle, className: cn("h-full", className), children: children }));
+}
+const chartEntry = (Chart) => ({
+    component: Chart,
+    needsShell: true,
+    render: (props) => (jsx(ChartContainer, { data: props.data, config: props.config, height: typeof props.height === "number" ? props.height : CHART_HEIGHT, className: "w-full", children: jsx(Chart, { ...props }) })),
+});
+const DEFAULT_COMPONENTS = {
+    // Layout containers — recursive children
+    Grid: { component: Grid, kind: "container" },
+    Stack: { component: Stack, kind: "container" },
+    Section: { component: Section, kind: "container" },
+    Card: {
+        component: Card,
+        kind: "container",
+        providesShell: true,
+        // Native title/subtitle slot-props + recursive children. h-full so a Card
+        // in a Grid cell fills the row (matching the auto needsShell wrap).
+        render: (props, children) => (jsx(LooseCard, { ...props, className: cn("h-full", props.className), children: children })),
+    },
+    // Self-contained leaves
+    Button: { component: Button, actionProps: { click: "onClick" } },
+    Metric: { component: Metric },
+    Alert: { component: Alert },
+    Badge: { component: Badge },
+    Avatar: { component: Avatar },
+    Progress: { component: Progress },
+    Separator: { component: Separator },
+    // Panel-less leaves — auto Card shell (lifted from the PoC's NEEDS_SHELL)
+    KPI: { component: KPI, needsShell: true },
+    // Collections (dual-API data path — items/data arrays are serializable)
+    Table: {
+        component: Table,
+        needsShell: true,
+        actionProps: { rowClick: "onRowClick" },
+        // Inside a padded Card: flush column edges + drop the last row's border.
+        render: (props) => (jsx(LooseTable, { ...props, padding: "flush", className: cn("[&_tbody_tr:last-child_td]:border-b-0", props.className) })),
+    },
+    Timeline: { component: Timeline },
+    DescriptionList: { component: DescriptionList },
+    Feed: { component: Feed },
+    // Charts — ChartContainer wrap + auto shell
+    AreaChart: chartEntry(AreaChart),
+    BarChart: chartEntry(BarChart),
+    LineChart: chartEntry(LineChart),
+    StackedBarChart: chartEntry(StackedBarChart),
+    ComboChart: chartEntry(ComboChart),
+    DonutChart: {
+        component: DonutChart,
+        needsShell: true,
+        render: (props) => (jsx("div", { className: "flex justify-center py-2", children: jsx(LooseDonutChart, { ...props }) })),
+    },
+};
+function createRegistry(options = {}) {
+    var _a, _b;
+    const components = { ...DEFAULT_COMPONENTS };
+    for (const [name, entry] of Object.entries((_a = options.components) !== null && _a !== void 0 ? _a : {})) {
+        if (entry === null)
+            delete components[name];
+        else
+            components[name] = entry;
+    }
+    return {
+        components,
+        icons: { ...DEFAULT_ICONS, ...options.icons },
+        resolvers: (_b = options.resolvers) !== null && _b !== void 0 ? _b : defaultResolvers,
+    };
+}
+/** The default generative-safe registry (curation expands in P5). */
+const defaultRegistry = createRegistry();
+
+export { CardShell, createRegistry, defaultRegistry };

package/dist/components/generative/resolvers.d.ts

@@ -0,0 +1,35 @@
+import React from "react";
+import { UINode } from "./types";
+/** Icon NAME → component map. The spec carries the NAME; we own the element. */
+export type IconMap = Record<string, React.ComponentType<{
+    className?: string;
+}>>;
+/** Closed default icon set (P2's schema generation emits these as the enum). */
+export declare const DEFAULT_ICONS: IconMap;
+export interface ResolverContext {
+    icons: IconMap;
+    node: UINode;
+}
+/**
+ * A resolver takes the (partially hydrated) props and returns the next props.
+ * Return the SAME object when nothing matched (cheap identity bail).
+ */
+export type PropResolver = (props: Record<string, unknown>, ctx: ResolverContext) => Record<string, unknown>;
+/** Resolve an icon NAME to an element (undefined when unknown — never throws). */
+export declare function resolveIcon(icons: IconMap, name: unknown, className?: string): React.ReactNode;
+/** icon / iconStart / iconEnd string values → Heroicon elements. */
+export declare const iconPropsResolver: PropResolver;
+/**
+ * Default status → Badge color map for `cellType: "badge"` columns. A column
+ * may override/extend it with a serializable `colors` map of its own.
+ */
+export declare const DEFAULT_STATUS_COLORS: Record<string, string>;
+/**
+ * Hydrate serializable Table column hints into real cell renderers.
+ * `{ cellType: "badge", colors? }` → a `cell` function rendering a soft Badge.
+ * Functions can't be serialized — the spec declares intent, we supply the fn.
+ */
+export declare const tableColumnsResolver: PropResolver;
+export declare const defaultResolvers: PropResolver[];
+/** Run the resolver chain over a node's props. */
+export declare function applyResolvers(props: Record<string, unknown>, resolvers: PropResolver[], ctx: ResolverContext): Record<string, unknown>;

package/dist/components/generative/resolvers.js

@@ -0,0 +1,93 @@
+import { jsx } from 'react/jsx-runtime';
+import React__default from 'react';
+import { ChatBubbleLeftRightIcon, PencilSquareIcon, RocketLaunchIcon, UserPlusIcon, BriefcaseIcon, ExclamationTriangleIcon, CheckCircleIcon, GlobeAltIcon, BoltIcon, ChartBarIcon, ShoppingCartIcon, ArrowTrendingUpIcon, UsersIcon, CurrencyDollarIcon } from '@heroicons/react/24/outline';
+import { Badge } from '../core/Badge/Badge.js';
+
+/** Closed default icon set (P2's schema generation emits these as the enum). */
+const DEFAULT_ICONS = {
+    CurrencyDollar: CurrencyDollarIcon,
+    Users: UsersIcon,
+    ArrowTrendingUp: ArrowTrendingUpIcon,
+    ShoppingCart: ShoppingCartIcon,
+    ChartBar: ChartBarIcon,
+    Bolt: BoltIcon,
+    Globe: GlobeAltIcon,
+    CheckCircle: CheckCircleIcon,
+    ExclamationTriangle: ExclamationTriangleIcon,
+    Briefcase: BriefcaseIcon,
+    UserPlus: UserPlusIcon,
+    RocketLaunch: RocketLaunchIcon,
+    PencilSquare: PencilSquareIcon,
+    ChatBubbleLeftRight: ChatBubbleLeftRightIcon,
+};
+/** Resolve an icon NAME to an element (undefined when unknown — never throws). */
+function resolveIcon(icons, name, className = "size-5") {
+    if (typeof name !== "string" || !icons[name])
+        return undefined;
+    return React__default.createElement(icons[name], { className });
+}
+const ICON_PROPS = ["icon", "iconStart", "iconEnd"];
+/** icon / iconStart / iconEnd string values → Heroicon elements. */
+const iconPropsResolver = (props, { icons }) => {
+    let next = null;
+    for (const key of ICON_PROPS) {
+        const value = props[key];
+        if (typeof value === "string") {
+            const element = resolveIcon(icons, value);
+            next = next !== null && next !== void 0 ? next : { ...props };
+            // Unknown name → drop the prop (a string would crash icon slots).
+            next[key] = element;
+        }
+    }
+    return next !== null && next !== void 0 ? next : props;
+};
+/**
+ * Default status → Badge color map for `cellType: "badge"` columns. A column
+ * may override/extend it with a serializable `colors` map of its own.
+ */
+const DEFAULT_STATUS_COLORS = {
+    Paid: "success",
+    Shipped: "primary",
+    Pending: "warning",
+    Refunded: "danger",
+};
+/**
+ * Hydrate serializable Table column hints into real cell renderers.
+ * `{ cellType: "badge", colors? }` → a `cell` function rendering a soft Badge.
+ * Functions can't be serialized — the spec declares intent, we supply the fn.
+ */
+const tableColumnsResolver = (props) => {
+    const columns = props.columns;
+    if (!Array.isArray(columns))
+        return props;
+    let changed = false;
+    const next = columns.map((col) => {
+        var _a, _b;
+        if (!col || typeof col !== "object" || col.cellType !== "badge") {
+            return col;
+        }
+        changed = true;
+        const { cellType: _cellType, colors, ...rest } = col;
+        const map = {
+            ...DEFAULT_STATUS_COLORS,
+            ...((_a = colors) !== null && _a !== void 0 ? _a : {}),
+        };
+        const accessor = (_b = col.accessor) !== null && _b !== void 0 ? _b : "";
+        return {
+            ...rest,
+            cell: (row) => {
+                var _a, _b;
+                const value = String((_a = row[accessor]) !== null && _a !== void 0 ? _a : "");
+                return (jsx(Badge, { color: ((_b = map[value]) !== null && _b !== void 0 ? _b : "neutral"), variant: "soft", children: value }));
+            },
+        };
+    });
+    return changed ? { ...props, columns: next } : props;
+};
+const defaultResolvers = [iconPropsResolver, tableColumnsResolver];
+/** Run the resolver chain over a node's props. */
+function applyResolvers(props, resolvers, ctx) {
+    return resolvers.reduce((acc, resolve) => resolve(acc, ctx), { ...props });
+}
+
+export { DEFAULT_ICONS, DEFAULT_STATUS_COLORS, applyResolvers, defaultResolvers, iconPropsResolver, resolveIcon, tableColumnsResolver };

package/dist/components/generative/schema.generated.d.ts

@@ -0,0 +1,2 @@
+import { GenerativeSchemaDoc } from "./schemaTypes";
+export declare const GENERATIVE_SCHEMA: GenerativeSchemaDoc;