a2uink 0.1.0

package/dist/src/renderer.js

@@ -0,0 +1,673 @@
+import React from "react";
+import { Box, render, Text, useInput, useStdout } from "ink";
+import { resolveBoundValue, setBoundValue } from "./binding.js";
+import { FocusProvider, useFocusRegistry } from "./focus.js";
+import { buildResolvedTree } from "./tree.js";
+import { renderNode } from "./catalog.js";
+export function createA2uiInkRenderer(options = {}) {
+    const surfaces = new Map();
+    let inkInstance = null;
+    const updateLocalDataModel = (surfaceId, path, value, node) => {
+        const surface = surfaces.get(surfaceId);
+        if (!surface) {
+            return;
+        }
+        surface.dataModel = setBoundValue(path, surface.dataModel, node.bindingContext, value);
+        renderSurfaces();
+    };
+    const ensureSurface = (surfaceId) => {
+        const existing = surfaces.get(surfaceId);
+        if (existing) {
+            return existing;
+        }
+        const created = {
+            surfaceId,
+            components: {},
+            dataModel: {},
+            renderReady: false
+        };
+        surfaces.set(surfaceId, created);
+        return created;
+    };
+    const renderSurfaces = () => {
+        var _a, _b;
+        const surface = Array.from(surfaces.values()).find((entry) => entry.renderReady && entry.rootComponentId);
+        const element = React.createElement(A2uiRoot, {
+            surface: surface !== null && surface !== void 0 ? surface : null,
+            onUserAction: options.onUserAction,
+            onLocalDataModelUpdate: updateLocalDataModel
+        });
+        if (!inkInstance) {
+            const canPatchConsole = typeof console !== "undefined" && typeof console.Console === "function";
+            const renderOptions = {
+                exitOnCtrlC: (_a = options.exitOnCtrlC) !== null && _a !== void 0 ? _a : true,
+                patchConsole: (_b = options.patchConsole) !== null && _b !== void 0 ? _b : canPatchConsole
+            };
+            if (options.stdin) {
+                renderOptions.stdin = options.stdin;
+            }
+            if (options.stdout) {
+                renderOptions.stdout = options.stdout;
+            }
+            if (options.stderr) {
+                renderOptions.stderr = options.stderr;
+            }
+            inkInstance = render(element, renderOptions);
+        }
+        else {
+            inkInstance.clear();
+            inkInstance.rerender(element);
+        }
+    };
+    const handleMessage = (message) => {
+        switch (message.type) {
+            case "beginRendering": {
+                const surface = ensureSurface(message.surfaceId);
+                surface.catalogId = message.catalogId;
+                surface.renderReady = true;
+                renderSurfaces();
+                break;
+            }
+            case "surfaceUpdate": {
+                const surface = ensureSurface(message.surfaceId);
+                surface.rootComponentId = message.rootComponentId;
+                surface.components = message.components.reduce((acc, component) => {
+                    const normalized = normalizeComponentDef(component);
+                    if (normalized) {
+                        acc[normalized.id] = normalized;
+                    }
+                    return acc;
+                }, {});
+                renderSurfaces();
+                break;
+            }
+            case "dataModelUpdate": {
+                const surface = ensureSurface(message.surfaceId);
+                if (message.dataModel) {
+                    surface.dataModel = mergeDataModel(surface.dataModel, message.dataModel);
+                }
+                else if (message.contents) {
+                    surface.dataModel = applyDataModelUpdate(surface.dataModel, message.path, message.contents);
+                }
+                renderSurfaces();
+                break;
+            }
+            case "deleteSurface": {
+                surfaces.delete(message.surfaceId);
+                renderSurfaces();
+                break;
+            }
+            default:
+                break;
+        }
+    };
+    const dispose = () => {
+        inkInstance === null || inkInstance === void 0 ? void 0 : inkInstance.unmount();
+        inkInstance = null;
+    };
+    return { handleMessage, dispose };
+}
+const A2uiRoot = ({ surface, onUserAction, onLocalDataModelUpdate }) => {
+    if (!surface || !surface.rootComponentId) {
+        return React.createElement(Text, null, "No surface");
+    }
+    const tree = buildResolvedTree(surface.components, surface.rootComponentId, surface.dataModel);
+    if (!tree) {
+        return React.createElement(Text, null, "Invalid surface");
+    }
+    return React.createElement(FocusProvider, null, React.createElement(FocusInputHandler), React.createElement(RootContainer, null, React.createElement(RenderTree, {
+        surfaceId: surface.surfaceId,
+        tree,
+        dataModel: surface.dataModel,
+        onUserAction,
+        onLocalDataModelUpdate
+    })));
+};
+const FocusInputHandler = () => {
+    const focus = useFocusRegistry();
+    useInput((input, key) => {
+        if (key.tab) {
+            if (key.shift) {
+                focus.focusPrev();
+            }
+            else {
+                focus.focusNext();
+            }
+            return;
+        }
+        focus.handleKey(input, key);
+    });
+    return null;
+};
+const RootContainer = ({ children }) => {
+    var _a, _b;
+    const { stdout } = useStdout();
+    const width = (_a = stdout === null || stdout === void 0 ? void 0 : stdout.columns) !== null && _a !== void 0 ? _a : undefined;
+    const height = (_b = stdout === null || stdout === void 0 ? void 0 : stdout.rows) !== null && _b !== void 0 ? _b : undefined;
+    return React.createElement(Box, { width, height, flexDirection: "column" }, children);
+};
+const RenderTree = ({ surfaceId, tree, dataModel, onUserAction, onLocalDataModelUpdate }) => {
+    const dispatchAction = (action, node, value) => {
+        var _a, _b;
+        const context = {
+            ...resolveActionContext(action.context, dataModel, node.bindingContext),
+            ...(((_a = node.bindingContext) === null || _a === void 0 ? void 0 : _a.index) !== undefined ? { index: node.bindingContext.index } : {}),
+            ...(((_b = node.bindingContext) === null || _b === void 0 ? void 0 : _b.item) !== undefined ? { item: node.bindingContext.item } : {})
+        };
+        onUserAction === null || onUserAction === void 0 ? void 0 : onUserAction({
+            type: "userAction",
+            surfaceId,
+            componentId: node.id,
+            actionId: action.actionId,
+            context,
+            value
+        });
+    };
+    const updateLocalDataModel = (path, value, node) => {
+        onLocalDataModelUpdate === null || onLocalDataModelUpdate === void 0 ? void 0 : onLocalDataModelUpdate(surfaceId, path, value, node);
+    };
+    return renderNode(tree, { dispatchAction, updateLocalDataModel });
+};
+function resolveActionContext(context, dataModel, bindingContext) {
+    if (!context) {
+        return {};
+    }
+    const resolved = {};
+    for (const [key, value] of Object.entries(context)) {
+        if (isBoundValueLike(value)) {
+            resolved[key] = resolveBoundValue(value, dataModel, bindingContext);
+        }
+        else {
+            resolved[key] = value;
+        }
+    }
+    return resolved;
+}
+function isBoundValueLike(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    return ("path" in value ||
+        "literalString" in value ||
+        "literalNumber" in value ||
+        "literalBoolean" in value ||
+        "literalObject" in value ||
+        "literalArray" in value);
+}
+function mergeDataModel(base, update) {
+    const result = { ...base };
+    for (const [key, value] of Object.entries(update)) {
+        if (isPlainObject(value) && isPlainObject(result[key])) {
+            result[key] = mergeDataModel(result[key], value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function isPlainObject(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeComponentDef(component) {
+    if (!component || typeof component !== "object") {
+        return null;
+    }
+    const record = component;
+    if (typeof record.id !== "string") {
+        return null;
+    }
+    if (typeof record.type === "string") {
+        const normalizedProps = normalizeBoundValuesDeep(record.props);
+        if (normalizedProps) {
+            if (normalizedProps.action && !normalizedProps.onPress && record.type === "Button") {
+                normalizedProps.onPress = normalizeAction(normalizedProps.action);
+                delete normalizedProps.action;
+            }
+            if (normalizedProps.action && !normalizedProps.onChange && (record.type === "Checkbox" || record.type === "CheckBox")) {
+                normalizedProps.onChange = normalizeAction(normalizedProps.action);
+                delete normalizedProps.action;
+            }
+        }
+        return {
+            id: record.id,
+            type: record.type,
+            props: normalizedProps,
+            children: normalizeChildren(record.children)
+        };
+    }
+    if (record.component && typeof record.component === "object") {
+        const [type, props] = extractComponentType(record.component);
+        if (!type) {
+            return null;
+        }
+        const { normalizedType, normalizedProps, children } = normalizeComponentShape(type, props);
+        if (!normalizedType) {
+            return null;
+        }
+        return {
+            id: record.id,
+            type: normalizedType,
+            props: normalizedProps,
+            children
+        };
+    }
+    return null;
+}
+function extractComponentType(componentObject) {
+    var _a, _b, _c;
+    if (typeof componentObject.type === "string") {
+        return [componentObject.type, (_a = componentObject.props) !== null && _a !== void 0 ? _a : {}];
+    }
+    const entries = Object.entries(componentObject);
+    if (entries.length === 1) {
+        const [type, props] = entries[0];
+        return [type, (_b = props) !== null && _b !== void 0 ? _b : {}];
+    }
+    const candidate = entries.find(([key, value]) => typeof key === "string" && typeof value === "object");
+    if (candidate) {
+        return [candidate[0], (_c = candidate[1]) !== null && _c !== void 0 ? _c : {}];
+    }
+    return [null, {}];
+}
+function normalizeComponentShape(type, props) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const nextProps = normalizeBoundValuesDeep({ ...(props !== null && props !== void 0 ? props : {}) });
+    let children = undefined;
+    if (nextProps.children) {
+        children = normalizeChildren(nextProps.children);
+        delete nextProps.children;
+    }
+    if (nextProps.child) {
+        children = normalizeChildren({ explicitList: [nextProps.child] });
+        delete nextProps.child;
+    }
+    if (nextProps.action && !nextProps.onPress && type === "Button") {
+        nextProps.onPress = normalizeAction(nextProps.action);
+        delete nextProps.action;
+    }
+    if (nextProps.action && !nextProps.onChange && (type === "Checkbox" || type === "CheckBox")) {
+        nextProps.onChange = normalizeAction(nextProps.action);
+        delete nextProps.action;
+    }
+    if (type === "Text" && nextProps.usageHint && nextProps.bold === undefined) {
+        const hint = String(nextProps.usageHint).toLowerCase();
+        if (hint === "h1" || hint === "h2" || hint === "h3") {
+            nextProps.bold = true;
+        }
+    }
+    if (type === "Row" || type === "Column") {
+        const direction = type === "Row" ? "row" : "column";
+        const alignItems = mapAlignment(nextProps.alignment);
+        const justifyContent = mapDistribution(nextProps.distribution);
+        return {
+            normalizedType: "Box",
+            normalizedProps: {
+                ...nextProps,
+                direction,
+                alignItems,
+                justifyContent
+            },
+            children
+        };
+    }
+    if (type === "Card") {
+        return {
+            normalizedType: "Box",
+            normalizedProps: {
+                direction: "column",
+                borderStyle: "round",
+                padding: 1,
+                ...nextProps
+            },
+            children
+        };
+    }
+    if (type === "Divider") {
+        return {
+            normalizedType: "Divider",
+            normalizedProps: nextProps,
+            children: undefined
+        };
+    }
+    if (type === "Icon") {
+        return {
+            normalizedType: "Text",
+            normalizedProps: {
+                text: resolveIconText(nextProps.name)
+            },
+            children: undefined
+        };
+    }
+    if (type === "Image") {
+        return {
+            normalizedType: "Image",
+            normalizedProps: nextProps,
+            children: undefined
+        };
+    }
+    if (type === "TextField") {
+        const textValue = (_a = nextProps.value) !== null && _a !== void 0 ? _a : nextProps.text;
+        return {
+            normalizedType: "TextField",
+            normalizedProps: {
+                label: nextProps.label,
+                value: textValue,
+                placeholder: (_b = nextProps.placeholder) !== null && _b !== void 0 ? _b : resolveLiteralString(nextProps.label),
+                onChange: nextProps.onChange,
+                onSubmit: nextProps.onSubmit
+            },
+            children: undefined
+        };
+    }
+    if (type === "CheckBox") {
+        return {
+            normalizedType: "Checkbox",
+            normalizedProps: {
+                label: nextProps.label,
+                checked: (_c = nextProps.checked) !== null && _c !== void 0 ? _c : nextProps.value,
+                onChange: (_d = nextProps.onChange) !== null && _d !== void 0 ? _d : normalizeAction(nextProps.action)
+            },
+            children: undefined
+        };
+    }
+    if (type === "MultipleChoice") {
+        return {
+            normalizedType: "MultipleChoice",
+            normalizedProps: {
+                label: nextProps.label,
+                items: normalizeMultipleChoiceOptions((_e = nextProps.options) !== null && _e !== void 0 ? _e : []),
+                onSelect: normalizeAction(nextProps.action)
+            },
+            children: undefined
+        };
+    }
+    if (type === "Slider") {
+        return {
+            normalizedType: "Slider",
+            normalizedProps: {
+                label: nextProps.label,
+                min: (_f = nextProps.min) !== null && _f !== void 0 ? _f : nextProps.minValue,
+                max: (_g = nextProps.max) !== null && _g !== void 0 ? _g : nextProps.maxValue,
+                step: nextProps.step,
+                value: nextProps.value,
+                onChange: (_h = nextProps.onChange) !== null && _h !== void 0 ? _h : normalizeAction(nextProps.action)
+            },
+            children: undefined
+        };
+    }
+    if (type === "Tabs") {
+        const tabItems = Array.isArray(nextProps.tabItems) ? nextProps.tabItems : [];
+        const tabLabels = tabItems.map((item) => { var _a; return (_a = resolveLiteralString(item === null || item === void 0 ? void 0 : item.title)) !== null && _a !== void 0 ? _a : "Tab"; });
+        if (!children && tabItems.length) {
+            const childIds = tabItems
+                .map((item) => item === null || item === void 0 ? void 0 : item.child)
+                .filter((entry) => typeof entry === "string");
+            if (childIds.length) {
+                children = { explicitList: childIds };
+            }
+        }
+        return {
+            normalizedType: "Tabs",
+            normalizedProps: {
+                tabs: tabLabels,
+                selectedIndex: (_j = nextProps.selectedIndex) !== null && _j !== void 0 ? _j : 0,
+                onChange: (_k = nextProps.onChange) !== null && _k !== void 0 ? _k : normalizeAction(nextProps.action)
+            },
+            children
+        };
+    }
+    if (type === "Modal") {
+        return {
+            normalizedType: "Modal",
+            normalizedProps: nextProps,
+            children
+        };
+    }
+    return {
+        normalizedType: type,
+        normalizedProps: nextProps,
+        children
+    };
+}
+function normalizeChildren(children) {
+    if (!children || typeof children !== "object")
+        return children;
+    const record = children;
+    if (Array.isArray(record.explicitList)) {
+        return { explicitList: record.explicitList };
+    }
+    if (record.template && typeof record.template === "object") {
+        const template = record.template;
+        const dataBinding = template.dataBinding;
+        return {
+            template: {
+                componentId: template.componentId,
+                dataBinding: typeof dataBinding === "string" ? dataBinding : dataBinding
+            }
+        };
+    }
+    return children;
+}
+function normalizeAction(action) {
+    if (!action || typeof action !== "object")
+        return undefined;
+    const record = action;
+    if (record.actionId && typeof record.actionId === "string") {
+        return { actionId: record.actionId, context: record.context };
+    }
+    if (record.name && typeof record.name === "string") {
+        return {
+            actionId: record.name,
+            context: normalizeActionContext(record.context)
+        };
+    }
+    return undefined;
+}
+function normalizeActionContext(context) {
+    if (!context)
+        return undefined;
+    if (Array.isArray(context)) {
+        const result = {};
+        context.forEach((entry) => {
+            var _a, _b;
+            if (!entry || typeof entry !== "object")
+                return;
+            const record = entry;
+            if (!record.key)
+                return;
+            result[String(record.key)] = (_b = (_a = record.value) !== null && _a !== void 0 ? _a : record.literal) !== null && _b !== void 0 ? _b : record;
+        });
+        return result;
+    }
+    if (typeof context === "object") {
+        return context;
+    }
+    return undefined;
+}
+function normalizeBoundValuesDeep(value) {
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeBoundValuesDeep(item));
+    }
+    if (isBoundValueLike(value)) {
+        return value;
+    }
+    const result = {};
+    Object.entries(value).forEach(([key, entry]) => {
+        result[key] = normalizeBoundValuesDeep(entry);
+    });
+    return result;
+}
+function resolveLiteralString(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    if (typeof record.literalString === "string") {
+        return record.literalString;
+    }
+    return undefined;
+}
+function normalizeMultipleChoiceOptions(options) {
+    if (!Array.isArray(options)) {
+        return options;
+    }
+    return options.map((option) => {
+        var _a;
+        if (!option || typeof option !== "object") {
+            return option;
+        }
+        const record = option;
+        const label = (_a = resolveLiteralString(record.label)) !== null && _a !== void 0 ? _a : record.label;
+        return {
+            ...record,
+            label
+        };
+    });
+}
+function resolveIconText(nameBinding) {
+    var _a;
+    const map = {
+        flight: "✈",
+        airplane: "✈",
+        plane: "✈",
+        calendar: "📅",
+        time: "⏰",
+        favorite: "★",
+        star: "★"
+    };
+    if (!nameBinding || typeof nameBinding !== "object") {
+        return { literalString: "•" };
+    }
+    const record = nameBinding;
+    if (typeof record.literalString === "string") {
+        const key = record.literalString.toLowerCase();
+        return { literalString: (_a = map[key]) !== null && _a !== void 0 ? _a : record.literalString };
+    }
+    if (typeof record.path === "string") {
+        return { path: record.path };
+    }
+    return { literalString: "•" };
+}
+function mapAlignment(alignment) {
+    if (!alignment)
+        return undefined;
+    const normalized = alignment.toLowerCase();
+    switch (normalized) {
+        case "start":
+        case "flexstart":
+        case "flex-start":
+            return "flex-start";
+        case "end":
+        case "flexend":
+        case "flex-end":
+            return "flex-end";
+        case "center":
+            return "center";
+        case "stretch":
+            return "stretch";
+        default:
+            return undefined;
+    }
+}
+function mapDistribution(distribution) {
+    if (!distribution)
+        return undefined;
+    const normalized = distribution.toLowerCase();
+    switch (normalized) {
+        case "spacebetween":
+        case "space-between":
+            return "space-between";
+        case "spacearound":
+        case "space-around":
+            return "space-around";
+        case "center":
+            return "center";
+        case "start":
+        case "flexstart":
+        case "flex-start":
+            return "flex-start";
+        case "end":
+        case "flexend":
+        case "flex-end":
+            return "flex-end";
+        default:
+            return undefined;
+    }
+}
+function applyDataModelUpdate(existing, path, contents) {
+    var _a;
+    const next = { ...(existing !== null && existing !== void 0 ? existing : {}) };
+    const updatedValue = buildValueFromContents(contents);
+    const parts = normalizePath(path);
+    if (!parts.length) {
+        if (isPlainObject(updatedValue)) {
+            return { ...next, ...updatedValue };
+        }
+        return (_a = updatedValue) !== null && _a !== void 0 ? _a : next;
+    }
+    let cursor = next;
+    for (let i = 0; i < parts.length - 1; i += 1) {
+        const key = parts[i];
+        if (!cursor[key] || typeof cursor[key] !== "object") {
+            cursor[key] = {};
+        }
+        cursor = cursor[key];
+    }
+    cursor[parts[parts.length - 1]] = updatedValue;
+    return next;
+}
+function normalizePath(path) {
+    if (!path || path === "/") {
+        return [];
+    }
+    const trimmed = String(path).replace(/^\/+/, "");
+    if (!trimmed) {
+        return [];
+    }
+    return trimmed.split("/").filter(Boolean);
+}
+function buildValueFromContents(contents) {
+    if (!Array.isArray(contents)) {
+        return contents;
+    }
+    const result = {};
+    contents.forEach((entry) => {
+        if (!entry || typeof entry !== "object") {
+            return;
+        }
+        result[entry.key] = extractTypedValue(entry);
+    });
+    return result;
+}
+function extractTypedValue(entry) {
+    var _a, _b;
+    if ("valueString" in entry)
+        return entry.valueString;
+    if ("valueNumber" in entry)
+        return entry.valueNumber;
+    if ("valueBoolean" in entry)
+        return entry.valueBoolean;
+    if ("valueNull" in entry)
+        return null;
+    if ("valueMap" in entry)
+        return buildValueFromContents((_a = entry.valueMap) !== null && _a !== void 0 ? _a : []);
+    if ("valueArray" in entry)
+        return normalizeValueArray((_b = entry.valueArray) !== null && _b !== void 0 ? _b : []);
+    if ("value" in entry)
+        return entry.value;
+    return undefined;
+}
+function normalizeValueArray(valueArray) {
+    return valueArray.map((item) => {
+        if (item && typeof item === "object" && "key" in item) {
+            return extractTypedValue(item);
+        }
+        if (item && typeof item === "object" && ("valueString" in item || "valueNumber" in item || "valueBoolean" in item || "valueMap" in item || "valueArray" in item || "valueNull" in item)) {
+            return extractTypedValue(item);
+        }
+        return item;
+    });
+}

package/dist/src/tree.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentDef, ResolvedNode } from "./types.js";
+export declare function buildResolvedTree(components: Record<string, ComponentDef>, rootId: string, dataModel: Record<string, unknown>): ResolvedNode | null;