@adonis-agora/agent/dist/src/react/core/genui/react-registry.js

Governed, durable-backed AI agent (chat + tool-calling + governance) for AdonisJS — part of the Agora ecosystem.

import { createElement } from 'react';
import { createComponentRegistry, } from '../../../genui/index.js';
/** App-scoped registry shared by GenuiProvider and static server rendering. */
export function createReactComponentRegistry(options) {
    const registry = createComponentRegistry(options);
    const components = Object.create(null);
    const texts = new Map();
    const paginators = new Map();
    const adapter = {
        get catalog() {
            return registry.catalog;
        },
        get manifest() {
            return registry.manifest;
        },
        get components() {
            return { ...components };
        },
        prepare: (presentation) => registry.prepare({ ...presentation, props: presentation.props }),
        render: (presentation, channel) => registry.render({ ...presentation, props: presentation.props }, channel),
        register(definition, renderers) {
            const ReactComponent = renderers.react;
            registry.register(definition, {
                ...(ReactComponent ? { react: (props) => createElement(ReactComponent, props) } : {}),
                ...(renderers.text ? { text: renderers.text } : {}),
            });
            if (renderers.react)
                components[definition.name] = renderers.react;
            if (renderers.text) {
                const text = renderers.text;
                texts.set(definition.name, (props) => text(props));
            }
            if (renderers.paginate) {
                const paginate = renderers.paginate;
                paginators.set(definition.name, async (props, size) => (await paginate(props, size)));
            }
            return adapter;
        },
        async renderPages(presentation, size) {
            const pages = await adapter.paginate(presentation, size);
            return Promise.all(pages.map(async (page) => {
                const ReactComponent = components[page.component];
                if (ReactComponent)
                    return createElement(ReactComponent, page.props);
                return texts.get(page.component)?.(page.props) ?? page.fallbackText;
            }));
        },
        async paginate(presentation, size) {
            if (!Number.isInteger(size) || size < 1 || size > 500)
                throw new RangeError('genui: rowsPerPage must be 1–500');
            const prepared = await registry.prepare({
                ...presentation,
                props: presentation.props,
            });
            const custom = paginators.get(prepared.component);
            const rows = prepared.props.rows;
            const pages = custom
                ? await custom(prepared.props, size)
                : prepared.component === 'DataTable' && Array.isArray(rows) && rows.length > size
                    ? Array.from({ length: Math.ceil(rows.length / size) }, (_, index) => ({
                        ...prepared.props,
                        rows: rows.slice(index * size, (index + 1) * size),
                    }))
                    : [prepared.props];
            if (!pages.length || pages.length > 100)
                throw new RangeError('genui: capture requires 1–100 pages');
            return Promise.all(pages.map((props) => registry.prepare({ ...prepared, props })));
        },
    };
    return adapter;
}
//# sourceMappingURL=react-registry.js.map