@antglobal/copilot-cards-mini-program 0.0.0 → 1.0.0

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 { 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';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

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,159 @@
+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 };
+//# sourceMappingURL=index.js.map

package/dist/renderer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

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,88 @@
+import { hasExpression, resolveExpression, resolveDeep, resolveExpressionValue } from '@antglobal/copilot-cards-core';
+
+/**
+ * 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
+    const 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);
+    }
+    // 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 };
+//# sourceMappingURL=transform.js.map

package/dist/renderer/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/streaming/index.d.ts

@@ -0,0 +1,80 @@
+import { StreamingCommand, ExpressionContext, StreamingParserOptions } from '@antglobal/copilot-cards-core';
+import { MiniProgramRenderNode } from '../renderer/index.js';
+import { MiniProgramAdapter } from '../adapter/index.js';
+
+/**
+ * Streaming Adapter for Mini-Program — enables progressive card rendering
+ * in WeChat/Alipay/DingTalk mini-programs via streaming commands.
+ *
+ * Since mini-programs cannot directly manipulate DOM, this module
+ * produces incremental setData patches that the framework can apply efficiently.
+ *
+ * Key differences from Web streaming:
+ * - Returns data patches instead of manipulating DOM
+ * - Uses path-based setData for efficient mini-program updates
+ * - Computes minimal diff for appendContent operations
+ */
+
+interface MiniProgramStreamingOptions {
+    /** Platform adapter instance */
+    adapter: MiniProgramAdapter;
+    /** Initial variables data context */
+    data?: ExpressionContext;
+    /** Bot ID for bot-scoped action handlers */
+    botId?: string;
+    /** Event emitter — called when an emit action fires */
+    onEmit?: (eventName: string, payload?: unknown) => void;
+    /** Parser options */
+    parserOptions?: StreamingParserOptions;
+}
+/**
+ * Represents a data patch that should be applied via mini-program's setData.
+ */
+interface DataPatch {
+    /** The path-value pairs for setData, e.g. { 'tree.children[0].props.content': 'new text' } */
+    data: Record<string, any>;
+}
+interface MiniProgramStreamingCardInstance {
+    /** Apply a single streaming command, returns setData patch or null */
+    applyCommand(command: StreamingCommand): DataPatch | null;
+    /** Apply multiple commands, returns array of patches */
+    applyCommands(commands: StreamingCommand[]): DataPatch[];
+    /** Feed raw text chunk, returns array of patches */
+    feed(chunk: string): DataPatch[];
+    /** Flush parser buffer, returns remaining patches */
+    flush(): DataPatch[];
+    /** Get current full render data */
+    getData(): {
+        tree: MiniProgramRenderNode | null;
+    };
+    /** Handle a component event */
+    handleEvent(nodeId: string, eventName: string, eventDetail?: any): Promise<DataPatch | null>;
+    /** Dispose the instance */
+    dispose(): void;
+}
+/**
+ * Create a mini-program streaming card instance.
+ *
+ * Unlike the web streaming renderer which directly updates DOM,
+ * this returns data patches that should be applied via the
+ * mini-program framework's setData mechanism.
+ *
+ * @example
+ * ```ts
+ * // In mini-program component
+ * const streaming = createStreamingCardInstance({
+ *   adapter: new AlipayAdapter(),
+ *   data: { userName: 'Alice' },
+ * });
+ *
+ * // Feed streaming data (e.g. from WebSocket)
+ * socket.onmessage = (e) => {
+ *   const patches = streaming.feed(e.data);
+ *   patches.forEach(patch => this.setData(patch.data));
+ * };
+ * ```
+ */
+declare function createStreamingCardInstance(options: MiniProgramStreamingOptions): MiniProgramStreamingCardInstance;
+
+export { createStreamingCardInstance };
+export type { DataPatch, MiniProgramStreamingCardInstance, MiniProgramStreamingOptions };

package/dist/streaming/index.js

@@ -0,0 +1,231 @@
+import { StreamingParser, StreamingEngine, normalizeSchema } from '@antglobal/copilot-cards-core';
+import { renderForMiniProgram } from '../renderer/index.js';
+
+/**
+ * Streaming Adapter for Mini-Program — enables progressive card rendering
+ * in WeChat/Alipay/DingTalk mini-programs via streaming commands.
+ *
+ * Since mini-programs cannot directly manipulate DOM, this module
+ * produces incremental setData patches that the framework can apply efficiently.
+ *
+ * Key differences from Web streaming:
+ * - Returns data patches instead of manipulating DOM
+ * - Uses path-based setData for efficient mini-program updates
+ * - Computes minimal diff for appendContent operations
+ */
+// ─── Main API ────────────────────────────────────────────────────
+/**
+ * Create a mini-program streaming card instance.
+ *
+ * Unlike the web streaming renderer which directly updates DOM,
+ * this returns data patches that should be applied via the
+ * mini-program framework's setData mechanism.
+ *
+ * @example
+ * ```ts
+ * // In mini-program component
+ * const streaming = createStreamingCardInstance({
+ *   adapter: new AlipayAdapter(),
+ *   data: { userName: 'Alice' },
+ * });
+ *
+ * // Feed streaming data (e.g. from WebSocket)
+ * socket.onmessage = (e) => {
+ *   const patches = streaming.feed(e.data);
+ *   patches.forEach(patch => this.setData(patch.data));
+ * };
+ * ```
+ */
+function createStreamingCardInstance(options) {
+    const parser = new StreamingParser(options.parserOptions);
+    let currentInstance = null;
+    let currentTree = null;
+    let variables = { ...options.data };
+    // Track node paths for efficient patching
+    const nodePathMap = new Map(); // elementId → setData path
+    /**
+     * Build the node path map by traversing the tree.
+     */
+    function buildNodePaths(node, basePath) {
+        nodePathMap.set(node.id, basePath);
+        node.children.forEach((child, index) => {
+            buildNodePaths(child, `${basePath}.children[${index}]`);
+        });
+    }
+    /**
+     * Create a full tree patch (for initial render or full re-render).
+     */
+    function createFullPatch() {
+        return { data: { tree: currentTree } };
+    }
+    // ─── Engine Setup ───────────────────────────────────────────────
+    const pendingPatches = [];
+    const engine = new StreamingEngine({
+        onSurfaceCreated(surfaceId, schemaInput) {
+            if (schemaInput) {
+                const schema = normalizeSchema(schemaInput);
+                variables = { ...schema.variables, ...options.data };
+                currentInstance = renderForMiniProgram(schema, {
+                    adapter: options.adapter,
+                    data: variables,
+                    botId: options.botId,
+                    onEmit: options.onEmit,
+                });
+                currentTree = currentInstance.getData().tree;
+                if (currentTree) {
+                    nodePathMap.clear();
+                    buildNodePaths(currentTree, 'tree');
+                }
+                pendingPatches.push(createFullPatch());
+            }
+        },
+        onComponentsUpdated(surfaceId, changes) {
+            // For mini-program, component tree changes require full re-render
+            // because we can't insert DOM nodes — we need to regenerate the data tree
+            const schema = engine.getSchema(surfaceId);
+            if (!schema)
+                return;
+            currentInstance = renderForMiniProgram(schema, {
+                adapter: options.adapter,
+                data: variables,
+                botId: options.botId,
+                onEmit: options.onEmit,
+            });
+            currentTree = currentInstance.getData().tree;
+            if (currentTree) {
+                nodePathMap.clear();
+                buildNodePaths(currentTree, 'tree');
+            }
+            pendingPatches.push(createFullPatch());
+        },
+        onDataModelUpdated(surfaceId, path, value) {
+            if (!currentInstance)
+                return;
+            // Update variables and regenerate tree
+            const pathParts = path.replace(/^\//, '').split('/').filter(Boolean);
+            if (pathParts.length === 0) {
+                if (typeof value === 'object' && value !== null) {
+                    variables = { ...variables, ...value };
+                }
+            }
+            else {
+                let current = variables;
+                for (let i = 0; i < pathParts.length - 1; i++) {
+                    if (current[pathParts[i]] === undefined)
+                        current[pathParts[i]] = {};
+                    current = current[pathParts[i]];
+                }
+                current[pathParts[pathParts.length - 1]] = value;
+            }
+            const result = currentInstance.updateVariables(variables);
+            currentTree = result.tree;
+            if (currentTree) {
+                nodePathMap.clear();
+                buildNodePaths(currentTree, 'tree');
+            }
+            pendingPatches.push(createFullPatch());
+        },
+        onContentAppended(surfaceId, elementId, content) {
+            // Try to do a targeted patch for text content
+            const nodePath = nodePathMap.get(elementId);
+            if (nodePath && currentTree) {
+                // Find the node and update its content in-place
+                const node = findNodeById(currentTree, elementId);
+                if (node) {
+                    const currentContent = typeof node.props.content === 'string'
+                        ? node.props.content : '';
+                    node.props.content = currentContent + content;
+                    // Generate a path-based setData patch for efficiency
+                    pendingPatches.push({
+                        data: { [`${nodePath}.props.content`]: node.props.content },
+                    });
+                    return;
+                }
+            }
+            // Fallback: full re-render
+            if (currentInstance) {
+                const schema = engine.getSchema(surfaceId);
+                if (schema) {
+                    variables = { ...schema.variables, ...variables };
+                    const result = currentInstance.updateVariables(variables);
+                    currentTree = result.tree;
+                    pendingPatches.push(createFullPatch());
+                }
+            }
+        },
+        onSurfaceDeleted(surfaceId) {
+            currentInstance?.dispose();
+            currentInstance = null;
+            currentTree = null;
+            nodePathMap.clear();
+            pendingPatches.push({ data: { tree: null } });
+        },
+    });
+    // ─── Helpers ────────────────────────────────────────────────────
+    function findNodeById(node, id) {
+        if (node.id === id)
+            return node;
+        for (const child of node.children) {
+            const found = findNodeById(child, id);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    function drainPatches() {
+        const patches = [...pendingPatches];
+        pendingPatches.length = 0;
+        return patches;
+    }
+    // ─── Public API ─────────────────────────────────────────────────
+    return {
+        applyCommand(command) {
+            engine.apply(command);
+            const patches = drainPatches();
+            return patches.length > 0 ? patches[patches.length - 1] : null;
+        },
+        applyCommands(commands) {
+            engine.applyBatch(commands);
+            return drainPatches();
+        },
+        feed(chunk) {
+            const commands = parser.parse(chunk);
+            for (const cmd of commands) {
+                engine.apply(cmd);
+            }
+            return drainPatches();
+        },
+        flush() {
+            const commands = parser.flush();
+            for (const cmd of commands) {
+                engine.apply(cmd);
+            }
+            return drainPatches();
+        },
+        getData() {
+            return { tree: currentTree };
+        },
+        async handleEvent(nodeId, eventName, eventDetail) {
+            if (!currentInstance)
+                return null;
+            await currentInstance.handleEvent(nodeId, eventName, eventDetail);
+            currentTree = currentInstance.getData().tree;
+            if (currentTree) {
+                nodePathMap.clear();
+                buildNodePaths(currentTree, 'tree');
+            }
+            return createFullPatch();
+        },
+        dispose() {
+            currentInstance?.dispose();
+            currentInstance = null;
+            currentTree = null;
+            nodePathMap.clear();
+            engine.dispose();
+            parser.reset();
+        },
+    };
+}
+
+export { createStreamingCardInstance };
+//# sourceMappingURL=index.js.map

package/dist/streaming/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}