@esheet/builder 0.0.4-0 → 0.0.4-1

package/dist/lib/mcp/tool-executor.js

@@ -0,0 +1,482 @@
+export function executeToolCall(toolName, args, tools) {
+    switch (toolName) {
+        case 'create_field':
+            return createField(args, tools);
+        case 'update_field':
+            return updateField(args, tools);
+        case 'delete_field':
+            return deleteField(args, tools);
+        case 'reset_form':
+            return resetForm(args, tools);
+        case 'generate_form':
+            return generateForm(args, tools);
+        case 'get_form_summary':
+            return getFormSummaryOptimized(tools);
+        case 'fill_field':
+            return fillField(args, tools);
+        case 'clear_responses':
+            tools.clearResponses();
+            return 'Responses cleared';
+        case 'get_responses':
+            return tools.getResponses();
+        case 'add_option':
+            return addOption(args, tools);
+        case 'update_option':
+            return updateOption(args, tools);
+        case 'remove_option':
+            return removeOption(args, tools);
+        case 'get_field':
+            return getFieldDetail(args, tools);
+        case 'move_field':
+            return moveField(args, tools);
+        case 'add_row':
+            return addRow(args, tools);
+        case 'update_row':
+            return updateRow(args, tools);
+        case 'remove_row':
+            return removeRow(args, tools);
+        case 'add_column':
+            return addColumn(args, tools);
+        case 'update_column':
+            return updateColumn(args, tools);
+        case 'remove_column':
+            return removeColumn(args, tools);
+        case 'get_field_types':
+            return { fieldTypes: tools.getFieldTypes() };
+        case 'get_field_spec':
+            return getFieldSpec(args, tools);
+        case 'get_definition':
+            return tools.getDefinition();
+        case 'set_form_id': {
+            const id = String(args['id'] ?? '');
+            if (!id)
+                return 'Error: id is required';
+            tools.setFormId(id);
+            return `Form ID set to "${id}"`;
+        }
+        case 'add_field_rule':
+            return addFieldRule(args, tools);
+        case 'add_expression_rule':
+            return addExpressionRule(args, tools);
+        case 'remove_rule':
+            return removeRule(args, tools);
+        default:
+            return `Unknown tool: ${toolName}`;
+    }
+}
+const PLACEHOLDER_IDS = new Set(['q1', 'q2', 'q3']);
+function createField(args, tools) {
+    // Auto-clear placeholder fields on first AI-created field.
+    const { fields } = tools.getFormSummary();
+    if (fields.length > 0 && fields.every((f) => PLACEHOLDER_IDS.has(f.id))) {
+        tools.resetForm({ id: 'form-1', fields: [] });
+    }
+    const fieldType = args.fieldType;
+    const patch = { question: args.question };
+    if (args.required !== undefined)
+        patch.required = args.required;
+    // Suppress auto-generated placeholder rows/columns on matrix fields so the
+    // AI doesn't have to remove them — it will add exactly what it needs.
+    if (fieldType === 'singlematrix' || fieldType === 'multimatrix') {
+        patch.rows = [];
+        patch.columns = [];
+    }
+    if (args.options) {
+        const opts = args.options;
+        patch.options = opts.map((o, i) => {
+            if (typeof o === 'string')
+                return { id: `o${i + 1}`, value: o };
+            const obj = o;
+            return { id: obj.id ?? `o${i + 1}`, value: obj.value ?? '' };
+        });
+    }
+    if (args.properties && typeof args.properties === 'object')
+        Object.assign(patch, args.properties);
+    let opts = { patch };
+    if (args.parentId) {
+        opts = { ...opts, parentId: args.parentId };
+    }
+    if (args.afterFieldId) {
+        const { fields } = tools.getFormSummary();
+        const afterIdx = fields.findIndex((f) => f.id === args.afterFieldId);
+        if (afterIdx >= 0)
+            opts = { ...opts, index: afterIdx + 1 };
+    }
+    const newId = tools.addField(fieldType, opts);
+    if (!newId)
+        return `Unknown field type: ${fieldType}`;
+    return `Created field "${args.question}" with ID: ${newId}`;
+}
+/** Optimized get_form_summary: condenses options/rows/columns to counts to reduce token usage. */
+function getFormSummaryOptimized(tools) {
+    const summary = tools.getFormSummary();
+    // Condense field details: replace full option arrays with counts
+    const condensedFields = summary.fields.map((f) => ({
+        id: f.id,
+        fieldType: f.fieldType,
+        question: f.question,
+        required: f.required,
+        optionCount: f.options?.length ?? 0,
+        rowCount: f.rows?.length ?? 0,
+        columnCount: f.columns?.length ?? 0,
+        editWith: f.editWith,
+        hasRules: f.hasRules,
+        hasValue: f.hasValue,
+        ...(f.valueFormat ? { valueFormat: f.valueFormat } : {}),
+    }));
+    return {
+        formId: summary.formId,
+        fieldCount: summary.fieldCount,
+        fields: condensedFields,
+        hint: 'Use get_field for full option/row/column details',
+    };
+}
+function fillField(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found: ${args.fieldId ?? args.fieldQuestion}`;
+    const result = tools.fillField(fieldId, args.value);
+    if (typeof result === 'string')
+        return result; // format validation error
+    if (!result)
+        return `Field not found: ${fieldId}`;
+    const summary = tools.getFormSummary();
+    const field = summary.fields.find((f) => f.id === fieldId);
+    const label = field?.question ?? fieldId;
+    // Return only unfilled fields with full details (token optimization)
+    const filledFields = summary.fields.filter((f) => f.hasValue);
+    const unfilledFields = summary.fields.filter((f) => !f.hasValue);
+    return {
+        result: `Filled "${label}" with ${JSON.stringify(args.value)}`,
+        filledCount: filledFields.length,
+        unfilledFields,
+    };
+}
+function generateForm(args, tools) {
+    const questions = args.questions;
+    if (!Array.isArray(questions) || questions.length === 0)
+        return `Missing 'questions' array — provide an array of { question, fieldType?, required?, inputType? }`;
+    return tools.generateForm(questions.slice(0, 5));
+}
+function resetForm(_args, tools) {
+    tools.resetForm({ id: 'form-1', fields: [] });
+    return 'Form cleared';
+}
+function updateField(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found: ${args.fieldId ?? args.fieldQuestion}`;
+    let updates = args.updates;
+    // Fallback: AI sometimes puts field props at the top level instead of inside `updates`.
+    // Collect any known field properties from top-level args.
+    if (updates === undefined || updates === null) {
+        const FIELD_PROPS = [
+            'question',
+            'required',
+            'inputType',
+            'unit',
+            'min',
+            'max',
+            'step',
+            'options',
+            'placeholder',
+        ];
+        const collected = {};
+        for (const key of FIELD_PROPS) {
+            if (args[key] !== undefined)
+                collected[key] = args[key];
+        }
+        if (Object.keys(collected).length > 0) {
+            updates = collected;
+        }
+        else {
+            return `Missing 'updates' object. Pass the properties to change as an object, e.g. { "question": "New text" }`;
+        }
+    }
+    if (typeof updates === 'string') {
+        try {
+            updates = JSON.parse(updates);
+        }
+        catch {
+            return `Invalid updates format: ${updates}`;
+        }
+    }
+    // For options, use surgical add/remove instead of replacing the whole array.
+    if (Array.isArray(updates['options'])) {
+        const newOptions = updates['options'];
+        const current = tools.getField(fieldId);
+        const currentOptions = current?.definition?.options ?? [];
+        // Remove options not in the new list.
+        for (const existing of currentOptions) {
+            const kept = newOptions.some((o) => (typeof o === 'string' ? o : o.value) ===
+                existing.value || o.id === existing.id);
+            if (!kept)
+                tools.option.remove(fieldId, existing.id);
+        }
+        // Add options not already present.
+        for (const o of newOptions) {
+            const value = typeof o === 'string' ? o : o.value ?? '';
+            const alreadyExists = currentOptions.some((ex) => ex.value === value);
+            if (!alreadyExists)
+                tools.option.add(fieldId, value);
+        }
+        // Strip options from the patch so updateField doesn't clobber the store.
+        const { options: _options, ...rest } = updates;
+        void _options;
+        updates = rest;
+    }
+    if (Object.keys(updates).length === 0)
+        return `Updated field ${fieldId}`;
+    if ('rows' in updates || 'columns' in updates)
+        return `Cannot set rows/columns via update_field. Use add_row/add_column to add items one at a time.`;
+    const ok = tools.updateField(fieldId, updates);
+    return ok ? `Updated field ${fieldId}` : `Field not found: ${fieldId}`;
+}
+function deleteField(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found: ${args.fieldId ?? args.fieldQuestion}`;
+    const ok = tools.removeField(fieldId);
+    return ok ? `Deleted field ${fieldId}` : `Field not found: ${fieldId}`;
+}
+function getFieldDetail(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found: ${args.fieldId ?? args.fieldQuestion}`;
+    const node = tools.getField(fieldId);
+    if (!node)
+        return `Field not found: ${fieldId}`;
+    const def = node.definition;
+    return { id: fieldId, ...def };
+}
+function moveField(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found: ${args.fieldId ?? args.fieldQuestion}`;
+    const toIndex = args.toIndex;
+    if (typeof toIndex !== 'number')
+        return `Missing 'toIndex' (number)`;
+    const ok = tools.moveField(fieldId, toIndex, args.toParentId ?? null);
+    return ok
+        ? `Moved field ${fieldId} to index ${toIndex}`
+        : `Failed to move field ${fieldId}`;
+}
+function addRow(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found`;
+    const fieldType = getFieldType(fieldId, tools);
+    if (fieldType && !MATRIX_TYPES.has(fieldType))
+        return `Field '${fieldId}' is a ${fieldType} field — rows only apply to singlematrix/multimatrix. Use add_option for option-based fields.`;
+    const rowId = tools.row.add(fieldId, args.value);
+    return rowId ? `Added row ${rowId}` : `Field not found or not a matrix field`;
+}
+function updateRow(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found`;
+    let rowId = args.rowId;
+    if (!rowId && args.value) {
+        const node = tools.getField(fieldId);
+        const rows = node?.definition?.rows ?? [];
+        const match = rows.find((r) => r.value === args.currentValue);
+        if (match)
+            rowId = match.id;
+    }
+    if (!rowId)
+        return `Missing 'rowId'`;
+    const ok = tools.row.update(fieldId, rowId, args.value);
+    return ok ? `Updated row ${rowId}` : `Row not found`;
+}
+function removeRow(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found`;
+    const ok = tools.row.remove(fieldId, args.rowId);
+    return ok ? `Removed row ${args.rowId}` : `Row not found`;
+}
+function addColumn(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found`;
+    const fieldType = getFieldType(fieldId, tools);
+    if (fieldType && !MATRIX_TYPES.has(fieldType))
+        return `Field '${fieldId}' is a ${fieldType} field — columns only apply to singlematrix/multimatrix fields.`;
+    const colId = tools.column.add(fieldId, args.value);
+    return colId
+        ? `Added column ${colId}`
+        : `Field not found or not a matrix field`;
+}
+function updateColumn(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found`;
+    let columnId = args.columnId;
+    if (!columnId && args.value) {
+        const node = tools.getField(fieldId);
+        const cols = node?.definition?.columns ?? [];
+        const match = cols.find((c) => c.value === args.currentValue);
+        if (match)
+            columnId = match.id;
+    }
+    if (!columnId)
+        return `Missing 'columnId'`;
+    const ok = tools.column.update(fieldId, columnId, args.value);
+    return ok ? `Updated column ${columnId}` : `Column not found`;
+}
+function removeColumn(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found`;
+    const ok = tools.column.remove(fieldId, args.columnId);
+    return ok ? `Removed column ${args.columnId}` : `Column not found`;
+}
+function getFieldSpec(args, tools) {
+    const fieldType = args.fieldType;
+    if (!fieldType)
+        return `Missing 'fieldType'`;
+    const spec = tools.getFieldSpec(fieldType);
+    if (!spec)
+        return `Unknown field type: ${fieldType}`;
+    return spec;
+}
+const MATRIX_TYPES = new Set(['singlematrix', 'multimatrix']);
+const OPTION_TYPES = new Set([
+    'radio',
+    'check',
+    'boolean',
+    'dropdown',
+    'multiselectdropdown',
+    'rating',
+    'ranking',
+    'slider',
+    'multitext',
+]);
+function getFieldType(fieldId, tools) {
+    const node = tools.getField(fieldId);
+    return node?.definition?.fieldType;
+}
+function addOption(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found`;
+    const fieldType = getFieldType(fieldId, tools);
+    if (fieldType && MATRIX_TYPES.has(fieldType))
+        return `'${fieldId}' is a ${fieldType} field — use add_row/add_column, not add_option.`;
+    if (fieldType && !OPTION_TYPES.has(fieldType))
+        return `'${fieldId}' is a ${fieldType} field — it does not support options.`;
+    const optId = tools.option.add(fieldId, args.value);
+    return optId
+        ? `Added option ${optId}`
+        : `Field not found or not an option field`;
+}
+function updateOption(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found`;
+    let optionId = args.optionId;
+    // Allow resolving by current label if id not provided
+    if (!optionId && args.currentValue) {
+        const node = tools.getField(fieldId);
+        const opts = node?.definition?.options ?? [];
+        const match = opts.find((o) => o.value === args.currentValue);
+        if (match)
+            optionId = match.id;
+    }
+    if (!optionId)
+        return `Missing 'optionId' or 'currentValue' to identify option`;
+    const ok = tools.option.update(fieldId, optionId, args.value);
+    return ok ? `Updated option ${optionId}` : `Option not found`;
+}
+function removeOption(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found`;
+    let optionId = args.optionId;
+    if (!optionId && args.currentValue) {
+        const node = tools.getField(fieldId);
+        const opts = node?.definition?.options ?? [];
+        const match = opts.find((o) => o.value === args.currentValue);
+        if (match)
+            optionId = match.id;
+    }
+    if (!optionId)
+        return `Missing 'optionId' or 'currentValue' to identify option`;
+    const ok = tools.option.remove(fieldId, optionId);
+    return ok ? `Removed option ${optionId}` : `Option not found`;
+}
+function addFieldRule(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found`;
+    const effect = args.effect;
+    const logic = args.logic ?? 'AND';
+    const conditions = args.conditions;
+    if (!effect)
+        return `Missing 'effect' (visible|enable|required)`;
+    if (!Array.isArray(conditions) || conditions.length === 0)
+        return `Missing 'conditions' array`;
+    const node = tools.getField(fieldId);
+    if (!node)
+        return `Field not found: ${fieldId}`;
+    const mappedConditions = conditions.map((c) => ({
+        conditionType: 'field',
+        targetId: c['targetId'],
+        operator: c['operator'],
+        ...(c['expected'] !== undefined && { expected: c['expected'] }),
+        ...(c['propertyAccessor'] !== undefined && {
+            propertyAccessor: c['propertyAccessor'],
+        }),
+    }));
+    const existing = node.definition.rules ?? [];
+    const newRule = { effect, logic, conditions: mappedConditions };
+    const ok = tools.updateField(fieldId, { rules: [...existing, newRule] });
+    return ok
+        ? `Added ${effect} field rule (index ${existing.length}) to field ${fieldId}`
+        : `Failed to update field ${fieldId}`;
+}
+function addExpressionRule(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found`;
+    const effect = args.effect;
+    const expression = args.expression;
+    if (!effect)
+        return `Missing 'effect' (visible|enable|required)`;
+    if (!expression?.trim())
+        return `Missing 'expression'`;
+    const node = tools.getField(fieldId);
+    if (!node)
+        return `Field not found: ${fieldId}`;
+    const existing = node.definition.rules ?? [];
+    const newRule = {
+        effect,
+        logic: 'AND',
+        conditions: [
+            { conditionType: 'expression', expression: expression.trim() },
+        ],
+    };
+    const ok = tools.updateField(fieldId, { rules: [...existing, newRule] });
+    return ok
+        ? `Added ${effect} expression rule (index ${existing.length}) to field ${fieldId}`
+        : `Failed to update field ${fieldId}`;
+}
+function removeRule(args, tools) {
+    const fieldId = tools.resolveFieldId(args.fieldId, args.fieldQuestion);
+    if (!fieldId)
+        return `Field not found`;
+    const ruleIndex = args.ruleIndex;
+    if (typeof ruleIndex !== 'number')
+        return `Missing 'ruleIndex' (number)`;
+    const node = tools.getField(fieldId);
+    if (!node)
+        return `Field not found: ${fieldId}`;
+    const existing = node.definition.rules ?? [];
+    if (ruleIndex < 0 || ruleIndex >= existing.length)
+        return `Rule index ${ruleIndex} out of range (field has ${existing.length} rule(s))`;
+    const updated = existing.filter((_, i) => i !== ruleIndex);
+    const ok = tools.updateField(fieldId, { rules: updated });
+    return ok
+        ? `Removed rule ${ruleIndex} from field ${fieldId}`
+        : `Failed to update field ${fieldId}`;
+}

package/dist/lib/mcp/useBuilderToolBridge.d.ts

@@ -0,0 +1,31 @@
+import type { BuilderTools } from '../builder-tools.js';
+export interface UseBuilderMcpToolHandlerOptions {
+    /**
+     * The DOM element to listen on for tool-call events.
+     * Pass `document` to listen globally, or a specific element to scope it.
+     */
+    target?: EventTarget;
+    /**
+     * The event name to listen for, e.g. `'ozwell-tool-call'`.
+     */
+    eventName: string;
+}
+/**
+ * Listens for AI tool-call events on a target element and dispatches them to
+ * the builder's MCP tool executor. Returns the `onBuilderToolsReady` callback
+ * to pass to `<EsheetBuilder>`.
+ *
+ * @example – default (listens on document)
+ * const onBuilderToolsReady = useBuilderMcpToolHandler();
+ * <EsheetBuilder onBuilderToolsReady={onBuilderToolsReady} />
+ *
+ * @example – scoped to a container element
+ * const ref = React.useRef<HTMLDivElement>(null);
+ * const onBuilderToolsReady = useBuilderMcpToolHandler({ target: ref.current ?? undefined });
+ * <div ref={ref}><EsheetBuilder onBuilderToolsReady={onBuilderToolsReady} /></div>
+ *
+ * @example – custom event name
+ * const onBuilderToolsReady = useBuilderMcpToolHandler({ eventName: 'my-ai-tool-call' });
+ */
+export declare function useBuilderMcpToolHandler(options: UseBuilderMcpToolHandlerOptions): (tools: BuilderTools) => void;
+//# sourceMappingURL=useBuilderToolBridge.d.ts.map

package/dist/lib/mcp/useBuilderToolBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBuilderToolBridge.d.ts","sourceRoot":"","sources":["../../../src/lib/mcp/useBuilderToolBridge.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGxD,MAAM,WAAW,+BAA+B;IAC9C;;;OAGG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,+BAA+B,GACvC,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAgD/B"}

package/dist/lib/mcp/useBuilderToolBridge.js

@@ -0,0 +1,56 @@
+import React from 'react';
+import { executeToolCall } from './tool-executor.js';
+/**
+ * Listens for AI tool-call events on a target element and dispatches them to
+ * the builder's MCP tool executor. Returns the `onBuilderToolsReady` callback
+ * to pass to `<EsheetBuilder>`.
+ *
+ * @example – default (listens on document)
+ * const onBuilderToolsReady = useBuilderMcpToolHandler();
+ * <EsheetBuilder onBuilderToolsReady={onBuilderToolsReady} />
+ *
+ * @example – scoped to a container element
+ * const ref = React.useRef<HTMLDivElement>(null);
+ * const onBuilderToolsReady = useBuilderMcpToolHandler({ target: ref.current ?? undefined });
+ * <div ref={ref}><EsheetBuilder onBuilderToolsReady={onBuilderToolsReady} /></div>
+ *
+ * @example – custom event name
+ * const onBuilderToolsReady = useBuilderMcpToolHandler({ eventName: 'my-ai-tool-call' });
+ */
+export function useBuilderMcpToolHandler(options) {
+    const { target, eventName } = options;
+    const toolsRef = React.useRef(null);
+    const onBuilderToolsReady = React.useCallback((tools) => {
+        toolsRef.current = tools;
+    }, []);
+    React.useEffect(() => {
+        const el = target ?? document;
+        function onToolCall(e) {
+            const { name: rawName, arguments: args, respond, } = e.detail;
+            // Strip 'postMessage:' prefix if present (added by Ozwell widget internally)
+            const name = rawName.replace(/^postMessage:/, '');
+            if (!toolsRef.current) {
+                respond({ success: false, message: 'Builder not ready' });
+                return;
+            }
+            const toResponse = (r) => typeof r === 'string' ? { result: r } : r;
+            try {
+                const result = executeToolCall(name, args, toolsRef.current);
+                if (result instanceof Promise) {
+                    result
+                        .then((r) => respond(toResponse(r)))
+                        .catch((err) => respond({ error: String(err) }));
+                }
+                else {
+                    respond(toResponse(result));
+                }
+            }
+            catch (err) {
+                respond({ error: String(err) });
+            }
+        }
+        el.addEventListener(eventName, onToolCall);
+        return () => el.removeEventListener(eventName, onToolCall);
+    }, [target, eventName]);
+    return onBuilderToolsReady;
+}

package/dist/lib/register-defaults.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureDefaultFieldComponentsRegistered(): void;
+//# sourceMappingURL=register-defaults.d.ts.map

package/dist/lib/register-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-defaults.d.ts","sourceRoot":"","sources":["../../src/lib/register-defaults.ts"],"names":[],"mappings":"AAkCA,wBAAgB,sCAAsC,IAAI,IAAI,CA0B7D"}

package/dist/lib/register-defaults.js

@@ -0,0 +1,37 @@
+// ---------------------------------------------------------------------------
+// Built-in field component registration
+// ---------------------------------------------------------------------------
+// Registers built-in field components for basic field types.
+// Explicitly invoked from EsheetBuilder at runtime via
+// ensureDefaultFieldComponentsRegistered().
+// Safe to call multiple times; registration is idempotent.
+// ---------------------------------------------------------------------------
+import { registerFieldComponents } from '@esheet/fields';
+import { TextField, LongTextField, MultiTextField, RadioField, CheckField, BooleanField, DropdownField, MultiSelectDropdownField, RatingField, RankingField, SliderField, SingleMatrixField, MultiMatrixField, SectionField, SignatureField, DiagramField, ImageField, HtmlField, DisplayField, } from '@esheet/fields';
+let defaultFieldComponentsRegistered = false;
+export function ensureDefaultFieldComponentsRegistered() {
+    if (defaultFieldComponentsRegistered)
+        return;
+    registerFieldComponents({
+        text: TextField,
+        longtext: LongTextField,
+        multitext: MultiTextField,
+        radio: RadioField,
+        check: CheckField,
+        boolean: BooleanField,
+        dropdown: DropdownField,
+        multiselectdropdown: MultiSelectDropdownField,
+        rating: RatingField,
+        ranking: RankingField,
+        slider: SliderField,
+        singlematrix: SingleMatrixField,
+        multimatrix: MultiMatrixField,
+        section: SectionField,
+        signature: SignatureField,
+        diagram: DiagramField,
+        image: ImageField,
+        html: HtmlField,
+        display: DisplayField,
+    });
+    defaultFieldComponentsRegistered = true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esheet/builder",
-  "version": "0.0.4-0",
+  "version": "0.0.4-1",
   "repository": {
     "type": "git",
     "url": "https://github.com/mieweb/eSheet"
@@ -38,9 +38,9 @@
     ]
   },
   "dependencies": {
-    "@esheet/adapters": "0.0.3",
-    "@esheet/core": "0.0.3",
-    "@esheet/fields": "0.0.3",
+    "@esheet/adapters": "0.0.4-1",
+    "@esheet/core": "0.0.4-1",
+    "@esheet/fields": "0.0.4-1",
     "@mieweb/ui": "^0.6.1",
     "@monaco-editor/react": "^4.7.0",
     "js-yaml": "^4.1.1",