@antglobal/copilot-cards-mini-program 0.0.0 → 0.0.20260724033338-dev.13

package/dist/components/card-text/index.d.ts

@@ -0,0 +1,23 @@
+import { MiniProgramRenderNode } from '../../renderer/index.js';
+
+/**
+ * card-text — Text component for mini-program.
+ * Renders text content with styling support.
+ */
+
+interface CardTextInstance {
+    props: {
+        node: MiniProgramRenderNode | null;
+    };
+    triggerEvent(name: string, detail?: any): void;
+}
+declare function createCardTextComponent(): {
+    props: {
+        node: null;
+    };
+    methods: {
+        onTap(this: CardTextInstance): void;
+    };
+};
+
+export { createCardTextComponent };

package/dist/components/card-text/index.js

@@ -0,0 +1,23 @@
+/**
+ * card-text — Text component for mini-program.
+ * Renders text content with styling support.
+ */
+function createCardTextComponent() {
+    return {
+        props: {
+            node: null,
+        },
+        methods: {
+            onTap() {
+                if (!this.props.node?.events.includes('onClick'))
+                    return;
+                this.triggerEvent('event', {
+                    nodeId: this.props.node.id,
+                    eventName: 'onClick',
+                });
+            },
+        },
+    };
+}
+
+export { createCardTextComponent };

package/dist/components/card-text/index.wxml

@@ -0,0 +1,8 @@
+<!-- card-text: WeChat template -->
+<view
+  class="card-text {{node.props.bold ? 'card-text--bold' : ''}} {{node.props.italic ? 'card-text--italic' : ''}}"
+  style="font-size: {{node.props.fontSize || '14px'}}; color: {{node.props.color || '#333333'}}; line-height: {{node.props.lineHeight || '1.5'}}; text-align: {{node.props.textAlign || 'left'}}; {{node.props.style ? node.props._styleString : ''}}"
+  bindtap="onTap"
+>
+  <text>{{node.props.content}}</text>
+</view>

package/dist/events/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Event system utilities for mini-program card components.
+ *
+ * Maps between schema event names and mini-program native events,
+ * and provides helpers for event bubbling.
+ */
+/**
+ * Map from mini-program native event names to schema event names.
+ * Mini-program templates use `bindtap`, `bindinput`, etc.
+ * Schema uses `onClick`, `onInput`, etc.
+ */
+declare const nativeToSchemaEventMap: Record<string, string>;
+/**
+ * Map from schema event names to Alipay mini-program event bindings.
+ */
+declare const schemaToAlipayEventMap: Record<string, string>;
+/**
+ * Map from schema event names to WeChat mini-program event bindings.
+ */
+declare const schemaToWeChatEventMap: Record<string, string>;
+interface CardEventDetail {
+    /** The node ID that triggered the event */
+    nodeId: string;
+    /** The schema event name (e.g. 'onClick', 'onInput') */
+    eventName: string;
+    /** Optional event value (e.g. input value) */
+    value?: unknown;
+    /** Additional event data */
+    [key: string]: unknown;
+}
+/**
+ * Create a standardized event detail object for triggerEvent.
+ */
+declare function createEventDetail(nodeId: string, eventName: string, extra?: Record<string, unknown>): CardEventDetail;
+
+export { createEventDetail, nativeToSchemaEventMap, schemaToAlipayEventMap, schemaToWeChatEventMap };
+export type { CardEventDetail };

package/dist/events/index.js

@@ -0,0 +1,50 @@
+/**
+ * Event system utilities for mini-program card components.
+ *
+ * Maps between schema event names and mini-program native events,
+ * and provides helpers for event bubbling.
+ */
+// ─── Event Name Mapping ──────────────────────────────────────────
+/**
+ * Map from mini-program native event names to schema event names.
+ * Mini-program templates use `bindtap`, `bindinput`, etc.
+ * Schema uses `onClick`, `onInput`, etc.
+ */
+const nativeToSchemaEventMap = {
+    tap: 'onClick',
+    input: 'onInput',
+    change: 'onChange',
+    confirm: 'onSubmit',
+    blur: 'onChange',
+    longpress: 'onLongPress',
+};
+/**
+ * Map from schema event names to Alipay mini-program event bindings.
+ */
+const schemaToAlipayEventMap = {
+    onClick: 'onTap',
+    onInput: 'onInput',
+    onChange: 'onBlur',
+    onSubmit: 'onConfirm',
+};
+/**
+ * Map from schema event names to WeChat mini-program event bindings.
+ */
+const schemaToWeChatEventMap = {
+    onClick: 'bindtap',
+    onInput: 'bindinput',
+    onChange: 'bindblur',
+    onSubmit: 'bindconfirm',
+};
+/**
+ * Create a standardized event detail object for triggerEvent.
+ */
+function createEventDetail(nodeId, eventName, extra) {
+    return {
+        nodeId,
+        eventName,
+        ...extra,
+    };
+}
+
+export { createEventDetail, nativeToSchemaEventMap, schemaToAlipayEventMap, schemaToWeChatEventMap };

package/dist/icons.d.ts

@@ -0,0 +1,3 @@
+declare function decorateMiniIconProps(props: Record<string, unknown>): Record<string, unknown>;
+
+export { decorateMiniIconProps };

package/dist/icons.js

@@ -0,0 +1,135 @@
+import { getBuiltinIcon } from '@antglobal/copilot-cards-core';
+
+const DEFAULT_ICON_SIZE = 24;
+const REPLACEMENT_CHARACTER = '\uFFFD';
+function normalizeXmlText(value) {
+    let normalized = '';
+    for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit >= 0xD800 && codeUnit <= 0xDBFF) {
+            const trailing = value.charCodeAt(index + 1);
+            if (trailing >= 0xDC00 && trailing <= 0xDFFF) {
+                normalized += value[index] + value[index + 1];
+                index += 1;
+            }
+            else {
+                normalized += REPLACEMENT_CHARACTER;
+            }
+            continue;
+        }
+        if (codeUnit >= 0xDC00 && codeUnit <= 0xDFFF) {
+            normalized += REPLACEMENT_CHARACTER;
+            continue;
+        }
+        const isAllowedXmlCharacter = codeUnit === 0x09 ||
+            codeUnit === 0x0A ||
+            codeUnit === 0x0D ||
+            (codeUnit >= 0x20 && codeUnit <= 0xD7FF) ||
+            (codeUnit >= 0xE000 && codeUnit <= 0xFFFD);
+        normalized += isAllowedXmlCharacter
+            ? value[index]
+            : REPLACEMENT_CHARACTER;
+    }
+    return normalized;
+}
+function escapeXmlAttr(value) {
+    return normalizeXmlText(value)
+        .replace(/&/g, '&amp;')
+        .replace(/"/g, '&quot;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+function resolveIconSize(value) {
+    const size = Number(value);
+    return Number.isFinite(size) && size > 0 ? size : DEFAULT_ICON_SIZE;
+}
+function normalizeStyleKey(key) {
+    if (key.startsWith('--')) {
+        return /^--[A-Za-z0-9_-]+$/.test(key) ? key : undefined;
+    }
+    if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(key))
+        return undefined;
+    return key
+        .replace(/([A-Z])/g, '-$1')
+        .toLowerCase();
+}
+function normalizeStyleValue(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? String(value) : undefined;
+    }
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = normalizeXmlText(value);
+    if (/[;{}]/.test(normalized))
+        return undefined;
+    const compact = normalized.replace(/[\s\u0000-\u001f]/g, '').toLowerCase();
+    if (/expression\(/.test(compact) ||
+        /url\((?:['"]?)(?:javascript|vbscript|file|data:text\/html):/.test(compact)) {
+        return undefined;
+    }
+    return normalized;
+}
+function serializeIconStyle(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return '';
+    const declarations = [];
+    for (const [rawKey, rawValue] of Object.entries(value)) {
+        const key = normalizeStyleKey(rawKey);
+        const styleValue = normalizeStyleValue(rawValue);
+        if (!key || styleValue === undefined)
+            continue;
+        declarations.push(`${key}: ${styleValue}`);
+    }
+    return declarations.join('; ');
+}
+function sanitizeExternalImageSrc(value) {
+    const src = String(value ?? '').trim();
+    if (!src)
+        return undefined;
+    const normalized = src.replace(/[\s\u0000-\u001f]/g, '').toLowerCase();
+    if (/^(javascript|vbscript|file):/.test(normalized))
+        return undefined;
+    if (/^data:/.test(normalized)) {
+        return /^data:image\/(?:png|jpeg|jpg|gif|webp);base64,/.test(normalized)
+            ? src
+            : undefined;
+    }
+    return src;
+}
+function decorateMiniIconProps(props) {
+    const size = resolveIconSize(props.size);
+    const name = props.name == null ? undefined : String(props.name);
+    const styleString = serializeIconStyle(props.style);
+    const decoratedProps = { ...props, _styleString: styleString };
+    if (props.src) {
+        const src = sanitizeExternalImageSrc(props.src);
+        if (src) {
+            return {
+                ...decoratedProps,
+                _iconKind: 'image',
+                _iconSrc: src,
+                _iconSize: size,
+            };
+        }
+    }
+    const icon = getBuiltinIcon(name);
+    if (icon) {
+        const color = escapeXmlAttr(String(props.color ?? 'currentColor'));
+        const svg = `<svg xmlns="http://www.w3.org/2000/svg" ` +
+            `viewBox="${icon.viewBox}" color="${color}">${icon.body}</svg>`;
+        return {
+            ...decoratedProps,
+            _iconKind: 'image',
+            _iconSrc: `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`,
+            _iconSize: size,
+        };
+    }
+    return {
+        ...decoratedProps,
+        _iconKind: 'text',
+        _iconText: name ?? '?',
+        _iconSize: size,
+    };
+}
+
+export { decorateMiniIconProps };

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export { MiniProgramAdapter, MiniProgramNavigateOptions, MiniProgramRequestOptions, MiniProgramResponse, MiniProgramSystemInfo, MiniProgramToastOptions } from './adapter/index.js';
+export { AlipayAdapter } from './adapter/alipay.js';
+export { WeChatAdapter } from './adapter/wechat.js';
+export { MiniProgramActionContextOptions, createMiniProgramActionContext } from './action-context/index.js';
+export { MiniProgramCardInstance, MiniProgramRenderNode, MiniProgramRendererOptions, renderForMiniProgram } from './renderer/index.js';
+export { createCardRootComponent } from './components/card-root/index.js';
+export { createCardNodeComponent } from './components/card-node/index.js';
+export { createCardTextComponent } from './components/card-text/index.js';
+export { createCardButtonComponent } from './components/card-button/index.js';
+export { createCardImageComponent } from './components/card-image/index.js';
+export { createCardIconComponent } from './components/card-icon/definition.js';
+export { createCardInputComponent } from './components/card-input/index.js';
+export { createCardDividerComponent } from './components/card-divider/index.js';
+export { CardEventDetail, createEventDetail, nativeToSchemaEventMap, schemaToAlipayEventMap, schemaToWeChatEventMap } from './events/index.js';
+export { DataPatch, MiniProgramStreamingCardInstance, MiniProgramStreamingOptions, createStreamingCardInstance } from './streaming/index.js';
+export { ActionRunnerContext, ActionStep, BuiltinIconName, CardSchema, CardSchemaInput, ElementNode, ExpressionContext, ExpressionValue, RenderTreeNode, convertLegacySchema, createLifecycleManager, hasExpression, isLegacySchema, normalizeSchema, parseSchema, registerActionHandler, resolveDeep, resolveExpression, runActionStep, runActionSteps, validateSchema } from '@antglobal/copilot-cards-core';
+export { transformNode, transformTree } from './renderer/transform.js';

package/dist/index.js

@@ -0,0 +1,16 @@
+export { AlipayAdapter } from './adapter/alipay.js';
+export { WeChatAdapter } from './adapter/wechat.js';
+export { createMiniProgramActionContext } from './action-context/index.js';
+export { renderForMiniProgram } from './renderer/index.js';
+export { createCardRootComponent } from './components/card-root/index.js';
+export { createCardNodeComponent } from './components/card-node/index.js';
+export { createCardTextComponent } from './components/card-text/index.js';
+export { createCardButtonComponent } from './components/card-button/index.js';
+export { createCardImageComponent } from './components/card-image/index.js';
+export { createCardIconComponent } from './components/card-icon/definition.js';
+export { createCardInputComponent } from './components/card-input/index.js';
+export { createCardDividerComponent } from './components/card-divider/index.js';
+export { createEventDetail, nativeToSchemaEventMap, schemaToAlipayEventMap, schemaToWeChatEventMap } from './events/index.js';
+export { createStreamingCardInstance } from './streaming/index.js';
+export { convertLegacySchema, createLifecycleManager, hasExpression, isLegacySchema, normalizeSchema, parseSchema, registerActionHandler, resolveDeep, resolveExpression, runActionStep, runActionSteps, validateSchema } from '@antglobal/copilot-cards-core';
+export { transformNode, transformTree } from './renderer/transform.js';

package/dist/renderer/index.d.ts

@@ -0,0 +1,67 @@
+import { ExpressionContext, CardSchemaInput } from '@antglobal/copilot-cards-core';
+import { MiniProgramAdapter } from '../adapter/index.js';
+export { transformNode, transformTree } from './transform.js';
+
+/**
+ * Mini-program renderer — converts a CardSchema into mini-program
+ * component-compatible data structures.
+ *
+ * Since mini-programs use their own template engines (WXML / AXML),
+ * this renderer doesn't produce DOM. Instead, it produces a normalised
+ * data tree that can be consumed by mini-program templates.
+ */
+
+interface MiniProgramRenderNode {
+    id: string;
+    type: string;
+    props: Record<string, unknown>;
+    children: MiniProgramRenderNode[];
+    visible: boolean;
+    /** Whether this element is in disabled state */
+    disabled: boolean;
+    /** Flattened event handler keys, e.g. ['onClick', 'onChange'] */
+    events: string[];
+}
+interface MiniProgramRendererOptions {
+    /** Initial variables data context */
+    data?: ExpressionContext;
+    /** Platform adapter instance */
+    adapter: MiniProgramAdapter;
+    /** Bot ID for bot-scoped action handlers */
+    botId?: string;
+    /** Event emitter — called when an emit action fires */
+    onEmit?: (eventName: string, payload?: unknown) => void;
+}
+interface MiniProgramCardInstance {
+    /** Get the current render data tree (pass to setData in mini-program component) */
+    getData(): {
+        tree: MiniProgramRenderNode;
+    };
+    /** Update variables and re-compute the data tree */
+    updateVariables(vars: Record<string, any>): {
+        tree: MiniProgramRenderNode;
+    };
+    /** Handle a component event (called from template bindtap/bindinput etc.) */
+    handleEvent(nodeId: string, eventName: string, eventDetail?: any): Promise<void>;
+    /** Dispose the card instance and clean up resources */
+    dispose(): void;
+}
+/**
+ * Create a mini-program card instance from a schema.
+ *
+ * Unlike the web `renderCard` which directly produces DOM, this function
+ * produces a data tree that mini-program templates consume via setData.
+ *
+ * @example
+ * ```ts
+ * const instance = renderForMiniProgram(schema, {
+ *   adapter: new AlipayAdapter(),
+ *   data: { userName: 'Alice' },
+ * });
+ * this.setData({ tree: instance.getData().tree });
+ * ```
+ */
+declare function renderForMiniProgram(schemaInput: CardSchemaInput, options: MiniProgramRendererOptions): MiniProgramCardInstance;
+
+export { renderForMiniProgram };
+export type { MiniProgramCardInstance, MiniProgramRenderNode, MiniProgramRendererOptions };

package/dist/renderer/index.js

@@ -0,0 +1,158 @@
+import { normalizeSchema, validateSchema, parseSchema, createLifecycleManager, runActionSteps, resolveActionRef } from '@antglobal/copilot-cards-core';
+import { createMiniProgramActionContext } from '../action-context/index.js';
+import { transformTree } from './transform.js';
+export { transformNode } from './transform.js';
+
+/**
+ * Mini-program renderer — converts a CardSchema into mini-program
+ * component-compatible data structures.
+ *
+ * Since mini-programs use their own template engines (WXML / AXML),
+ * this renderer doesn't produce DOM. Instead, it produces a normalised
+ * data tree that can be consumed by mini-program templates.
+ */
+// ─── Main API ────────────────────────────────────────────────────
+/**
+ * Create a mini-program card instance from a schema.
+ *
+ * Unlike the web `renderCard` which directly produces DOM, this function
+ * produces a data tree that mini-program templates consume via setData.
+ *
+ * @example
+ * ```ts
+ * const instance = renderForMiniProgram(schema, {
+ *   adapter: new AlipayAdapter(),
+ *   data: { userName: 'Alice' },
+ * });
+ * this.setData({ tree: instance.getData().tree });
+ * ```
+ */
+function renderForMiniProgram(schemaInput, options) {
+    // 0. Normalize schema (auto-convert legacy format)
+    const schema = normalizeSchema(schemaInput);
+    // 1. Validate
+    const errors = validateSchema(schema);
+    if (errors.length > 0) {
+        throw new Error(`[renderForMiniProgram] Invalid schema:\n${errors.join('\n')}`);
+    }
+    // 2. Parse into render tree
+    const tree = parseSchema(schema);
+    // 3. Reactive variables store
+    let variables = { ...schema.variables, ...options.data };
+    // 4. Schema-level action definitions
+    const schemaActions = schema.actions ?? {};
+    // 5. Event-node mapping (for fast lookup on handleEvent)
+    const nodeEventsMap = buildNodeEventsMap(tree, schemaActions);
+    // 6. Lifecycle manager
+    const lifecycleManager = createLifecycleManager();
+    const abortController = new AbortController();
+    // 7. Action context
+    let actionContext = createMiniProgramActionContext(options.adapter, {
+        setVariable: (key, value) => {
+            variables[key] = value;
+        },
+        emit: options.onEmit,
+        variables,
+        botId: options.botId,
+        abortSignal: abortController.signal,
+    });
+    function rebuildActionContext() {
+        actionContext = createMiniProgramActionContext(options.adapter, {
+            setVariable: (key, value) => {
+                variables[key] = value;
+            },
+            emit: options.onEmit,
+            variables,
+            botId: options.botId,
+            abortSignal: abortController.signal,
+        });
+    }
+    // 8. Register lifecycles and trigger mount
+    registerLifecycles(tree, lifecycleManager, actionContext);
+    // 9. Compute initial data
+    let currentTree = transformTree(tree, variables);
+    // ── Instance API ───────────────────────────────────────────────
+    return {
+        getData() {
+            return { tree: currentTree };
+        },
+        updateVariables(newVars) {
+            variables = { ...variables, ...newVars };
+            rebuildActionContext();
+            currentTree = transformTree(tree, variables);
+            return { tree: currentTree };
+        },
+        async handleEvent(nodeId, eventName, eventDetail) {
+            // Write event detail to _event variable
+            if (eventDetail != null) {
+                variables._event = eventDetail;
+            }
+            // Handle variableKey auto-sync for input events
+            if (eventName === 'onInput' || eventName === 'onChange') {
+                const nodeInfo = nodeEventsMap.get(nodeId);
+                if (nodeInfo?.variableKey && eventDetail?.value !== undefined) {
+                    variables[nodeInfo.variableKey] = eventDetail.value;
+                }
+            }
+            // Look up action steps for this node + event
+            const nodeInfo = nodeEventsMap.get(nodeId);
+            const steps = nodeInfo?.events[eventName];
+            if (steps) {
+                rebuildActionContext();
+                await runActionSteps(steps, actionContext);
+            }
+            // Re-compute tree after action execution (variables may have changed)
+            rebuildActionContext();
+            currentTree = transformTree(tree, variables);
+        },
+        dispose() {
+            abortController.abort();
+            lifecycleManager.dispose(actionContext);
+        },
+    };
+}
+/**
+ * Build a map of nodeId → { events, variableKey } for fast event lookup.
+ */
+function buildNodeEventsMap(tree, schemaActions) {
+    const map = new Map();
+    function walk(node) {
+        const events = {};
+        if (node.events) {
+            for (const [eventName, eventValue] of Object.entries(node.events)) {
+                if (!eventValue)
+                    continue;
+                const resolvedSteps = resolveActionRef(eventValue, schemaActions);
+                if (resolvedSteps) {
+                    events[eventName] = resolvedSteps;
+                }
+            }
+        }
+        const variableKey = node.props?.variableKey;
+        if (Object.keys(events).length > 0 || variableKey) {
+            map.set(node.id, { events, variableKey });
+        }
+        for (const child of node.children) {
+            walk(child);
+        }
+    }
+    walk(tree);
+    return map;
+}
+/**
+ * Register lifecycle hooks for all nodes in the tree.
+ */
+function registerLifecycles(tree, lifecycleManager, actionContext) {
+    function walk(node) {
+        if (node.lifecycle) {
+            lifecycleManager.register(node.id, node.lifecycle);
+            lifecycleManager.mount(node.id, actionContext);
+        }
+        for (const child of node.children) {
+            walk(child);
+        }
+    }
+    walk(tree);
+}
+
+export { renderForMiniProgram, transformTree };

package/dist/renderer/transform.d.ts

@@ -0,0 +1,24 @@
+import { RenderTreeNode } from '@antglobal/copilot-cards-core';
+import { MiniProgramRenderNode } from './index.js';
+
+/**
+ * Transform — converts a RenderTreeNode into a MiniProgramRenderNode.
+ *
+ * Performs expression resolution, directive evaluation, and event collection
+ * to produce a plain data object consumable by mini-program templates via setData.
+ */
+
+/**
+ * Recursively transform a RenderTreeNode into a MiniProgramRenderNode.
+ *
+ * This resolves all expressions against the current variables,
+ * evaluates directives (visible, disabled), and flattens events
+ * into a list of event names for template binding.
+ */
+declare function transformNode(node: RenderTreeNode, variables: Record<string, any>): MiniProgramRenderNode;
+/**
+ * Transform an entire render tree into a mini-program data tree.
+ */
+declare function transformTree(tree: RenderTreeNode, variables: Record<string, any>): MiniProgramRenderNode;
+
+export { transformNode, transformTree };

package/dist/renderer/transform.js

@@ -0,0 +1,91 @@
+import { hasExpression, resolveExpression, resolveDeep, resolveExpressionValue } from '@antglobal/copilot-cards-core';
+import { decorateMiniIconProps } from '../icons.js';
+
+/**
+ * Transform — converts a RenderTreeNode into a MiniProgramRenderNode.
+ *
+ * Performs expression resolution, directive evaluation, and event collection
+ * to produce a plain data object consumable by mini-program templates via setData.
+ */
+// ─── Transform ───────────────────────────────────────────────────
+/**
+ * Recursively transform a RenderTreeNode into a MiniProgramRenderNode.
+ *
+ * This resolves all expressions against the current variables,
+ * evaluates directives (visible, disabled), and flattens events
+ * into a list of event names for template binding.
+ */
+function transformNode(node, variables) {
+    // 1. Check directives.visible
+    let visible = true;
+    if (node.directives?.visible) {
+        const visibleExpr = node.directives.visible;
+        const resolved = hasExpression(visibleExpr)
+            ? resolveExpression(visibleExpr, variables)
+            : visibleExpr;
+        if (resolved === false || resolved === 'false' || resolved === '' || resolved === 0) {
+            visible = false;
+        }
+    }
+    // If not visible, return early with minimal node (children won't be resolved)
+    if (!visible) {
+        return {
+            id: node.id,
+            type: node.type,
+            props: {},
+            children: [],
+            visible: false,
+            disabled: false,
+            events: [],
+        };
+    }
+    // 2. Resolve props with variable expressions
+    let resolvedProps = resolveDeep(node.props, variables);
+    // Resolve content if it's an ExpressionValue object
+    if (resolvedProps.content &&
+        typeof resolvedProps.content === 'object' &&
+        resolvedProps.content !== null &&
+        'type' in resolvedProps.content) {
+        resolvedProps.content = resolveExpressionValue(resolvedProps.content, variables);
+    }
+    if (node.type === 'Icon') {
+        resolvedProps = decorateMiniIconProps(resolvedProps);
+    }
+    // 3. Check directives.disabled
+    let disabled = false;
+    if (node.directives?.disabled) {
+        const disabledExpr = node.directives.disabled;
+        const resolved = hasExpression(disabledExpr)
+            ? resolveExpression(disabledExpr, variables)
+            : disabledExpr;
+        disabled = resolved === true || resolved === 'true' || resolved === 1;
+    }
+    // 4. Collect event names
+    const events = [];
+    if (node.events && !disabled) {
+        for (const eventName of Object.keys(node.events)) {
+            if (node.events[eventName]) {
+                events.push(eventName);
+            }
+        }
+    }
+    // 5. Recursively transform children
+    const children = node.children.map((child) => transformNode(child, variables));
+    return {
+        id: node.id,
+        type: node.type,
+        props: resolvedProps,
+        children,
+        visible,
+        disabled,
+        events,
+    };
+}
+/**
+ * Transform an entire render tree into a mini-program data tree.
+ */
+function transformTree(tree, variables) {
+    return transformNode(tree, variables);
+}
+
+export { transformNode, transformTree };