@kubohiroya/turbowarp-extension-data-editor 0.2.0 → 0.2.2

package/dist/fixed-input-snapshot.js

@@ -0,0 +1,180 @@
+import { snapshotJson } from './schema-json.js';
+import { captureFixedBranchRules } from './fixed-input-branches.js';
+function fail() { throw new TypeError('Invalid fixed-input contract or snapshot.'); }
+/** Read each own data property once; accessors and prototype values cannot supply data. */
+function own(value, key) {
+    if (!value || typeof value !== 'object')
+        return fail();
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !('value' in descriptor))
+        return fail();
+    return descriptor.value;
+}
+function text(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        return fail();
+    return value;
+}
+function record(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return fail();
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return fail();
+    if (Object.getOwnPropertySymbols(value).length)
+        return fail();
+    return value;
+}
+function names(value) {
+    if (!Array.isArray(value))
+        return fail();
+    const items = [];
+    for (let i = 0; i < value.length; i++)
+        items.push(text(own(value, String(i))));
+    if (new Set(items).size !== items.length)
+        return fail();
+    return Object.freeze(items);
+}
+function dependencies(value, editable) {
+    if (!Array.isArray(value))
+        return fail();
+    const selectors = new Set();
+    const result = [];
+    for (let i = 0; i < value.length; i++) {
+        const item = record(own(value, String(i)));
+        const selector = text(own(item, 'selector'));
+        const dependents = names(own(item, 'dependents'));
+        if (!editable.has(selector) || selectors.has(selector) || dependents.length === 0 ||
+            dependents.some(name => name === selector || !editable.has(name)))
+            return fail();
+        selectors.add(selector);
+        result.push(Object.freeze({ selector, dependents }));
+    }
+    return Object.freeze(result);
+}
+export function captureFixedInputDeclaration(value) {
+    const policy = Object.getOwnPropertyDescriptor(value, 'branchRules');
+    if (policy && !('value' in policy))
+        return fail();
+    const captured = record(snapshotJson({
+        contractId: own(value, 'contractId'), contractRevision: own(value, 'contractRevision'),
+        editableArguments: own(value, 'editableArguments'), readOnlyArguments: own(value, 'readOnlyArguments'),
+        dependencies: own(value, 'dependencies')
+    }));
+    const editableArguments = names(captured.editableArguments);
+    const readOnlyArguments = names(captured.readOnlyArguments);
+    const editable = new Set(editableArguments);
+    if (editable.size === 0 || readOnlyArguments.some(name => editable.has(name)))
+        return fail();
+    const groups = dependencies(captured.dependencies, editable);
+    const branchRules = captureFixedBranchRules(policy === null || policy === void 0 ? void 0 : policy.value, groups, readOnlyArguments);
+    return Object.freeze({
+        contractId: text(captured.contractId), contractRevision: text(captured.contractRevision),
+        editableArguments, readOnlyArguments, dependencies: groups,
+        ...((policy === null || policy === void 0 ? void 0 : policy.value) === undefined ? {} : { branchRules })
+    });
+}
+export const validateFixedInputDeclaration = captureFixedInputDeclaration;
+function canonical(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(',')}]`;
+    const item = value;
+    return `{${Object.keys(item).sort().map(key => `${JSON.stringify(key)}:${canonical(item[key])}`).join(',')}}`;
+}
+function sameNames(left, right) {
+    return left.length === right.length && left.every(name => right.includes(name));
+}
+/** Preserve raw literals with Object.is semantics while copying metadata as finite JSON. */
+export function captureFixedSnapshot(value, reference, declaration) {
+    record(value);
+    const targetId = text(own(value, 'targetId'));
+    const blockId = text(own(value, 'blockId'));
+    if (reference && (targetId !== own(reference, 'targetId') || blockId !== own(reference, 'blockId')))
+        return fail();
+    const opcode = text(own(value, 'opcode'));
+    const revision = text(own(value, 'revision'));
+    const inputArguments = record(own(value, 'arguments'));
+    const argumentsCopy = Object.create(null);
+    for (const name of Object.keys(inputArguments)) {
+        const item = record(own(inputArguments, name));
+        const kind = own(item, 'kind');
+        if (kind === 'reporter')
+            argumentsCopy[name] = Object.freeze({ kind });
+        else if (kind === 'literal') {
+            const raw = own(item, 'value');
+            if (typeof raw !== 'string' && typeof raw !== 'number' && typeof raw !== 'boolean')
+                return fail();
+            argumentsCopy[name] = Object.freeze({ kind, value: raw });
+        }
+        else
+            return fail();
+    }
+    const context = record(snapshotJson(own(value, 'fixedContext')));
+    const contractId = text(context.contractId);
+    const contractRevision = text(context.contractRevision);
+    const generation = text(context.generation);
+    const readOnlyArguments = names(context.readOnlyArguments);
+    const inputMetadata = record(context.inputs);
+    const editable = new Set();
+    const inputs = Object.create(null);
+    for (const name of Object.keys(inputMetadata)) {
+        const item = record(inputMetadata[name]);
+        if (item.role !== 'editable' && item.role !== 'readonly')
+            return fail();
+        const role = item.role;
+        if ((role === 'readonly') !== readOnlyArguments.includes(name))
+            return fail();
+        if (role === 'editable')
+            editable.add(name);
+        const source = item.source;
+        if (source !== 'shadow' && source !== 'field' && source !== 'reporter' && source !== 'unsupported' && source !== 'missing')
+            return fail();
+        const slot = argumentsCopy[name];
+        if ((source === 'shadow' || source === 'field') && (slot === null || slot === void 0 ? void 0 : slot.kind) !== 'literal')
+            return fail();
+        if (source === 'reporter' && (slot === null || slot === void 0 ? void 0 : slot.kind) !== 'reporter')
+            return fail();
+        if (source === 'missing' && (slot === null || slot === void 0 ? void 0 : slot.kind) === 'literal')
+            return fail();
+        let field;
+        if (source === 'shadow' || source === 'field') {
+            const capturedField = record(item.field);
+            field = Object.freeze({ blockId: text(capturedField.blockId), name: text(capturedField.name), type: text(capturedField.type) });
+        }
+        else if (item.field !== undefined)
+            return fail();
+        if (item.reason !== undefined && typeof item.reason !== 'string')
+            return fail();
+        if ((source === 'unsupported' || source === 'missing') && !item.reason)
+            return fail();
+        inputs[name] = Object.freeze({ role, source, identity: text(item.identity),
+            ...(field ? { field } : {}), ...(item.reason === undefined ? {} : { reason: item.reason }) });
+    }
+    if (readOnlyArguments.some(name => !Object.hasOwn(inputs, name)))
+        return fail();
+    const capturedDependencies = dependencies(context.dependencies, editable);
+    if (declaration) {
+        const expected = captureFixedInputDeclaration(declaration);
+        if (contractId !== expected.contractId || contractRevision !== expected.contractRevision ||
+            !sameNames([...editable], expected.editableArguments) || !sameNames(readOnlyArguments, expected.readOnlyArguments) ||
+            canonical(capturedDependencies) !== canonical(expected.dependencies))
+            return fail();
+    }
+    return Object.freeze({ targetId, blockId, opcode, revision, arguments: Object.freeze(argumentsCopy),
+        fixedContext: Object.freeze({ contractId, contractRevision, generation, readOnlyArguments,
+            dependencies: capturedDependencies, inputs: Object.freeze(inputs) }) });
+}
+export function sameFixedSnapshot(left, right) {
+    const a = captureFixedSnapshot(left);
+    const b = captureFixedSnapshot(right);
+    const keys = Object.keys(a.arguments);
+    return a.targetId === b.targetId && a.blockId === b.blockId && a.opcode === b.opcode && a.revision === b.revision &&
+        canonical(a.fixedContext) === canonical(b.fixedContext) && keys.length === Object.keys(b.arguments).length &&
+        keys.every(name => {
+            const x = a.arguments[name];
+            const y = b.arguments[name];
+            return !!y && x.kind === y.kind && (x.kind === 'reporter' || (y.kind === 'literal' && Object.is(x.value, y.value)));
+        });
+}

package/dist/fixed-input-types.d.ts

@@ -0,0 +1,138 @@
+import type { BlockEditorHost, BlockReference, BlockSnapshot, EditorDefinition, JsonObject, JsonValue, LiteralArgumentChange, ValidationIssue } from './types.js';
+import type { SchemaJsonValue, SchemaValidationContext } from './schema-types.js';
+export declare const FIXED_INPUTS_CAPABILITY: "fixed-inputs-v1";
+export interface FixedInputDependency {
+    readonly selector: string;
+    readonly dependents: readonly string[];
+}
+/** Finite owner-declared branch rules; the host never evaluates owner code. */
+export interface FixedInputBranchCase {
+    readonly values: readonly string[];
+    readonly activeDependents: readonly string[];
+    readonly requireOnSelectorChange?: readonly {
+        readonly argument: string;
+        readonly rule: 'literal' | 'nonempty-string';
+    }[];
+}
+export interface FixedInputBranchRule {
+    readonly selector: string;
+    readonly normalize?: {
+        readonly trim?: boolean;
+        readonly lowercase?: boolean;
+    };
+    readonly cases: readonly FixedInputBranchCase[];
+}
+export interface FixedInputControl {
+    readonly kind: 'text' | 'number' | 'enum' | 'color';
+    readonly label?: string;
+    readonly choices?: readonly {
+        readonly value: JsonValue;
+        readonly label?: string;
+    }[];
+    readonly reset?: JsonValue;
+}
+export interface FixedInputViewInput {
+    readonly state: 'editable' | 'readonly' | 'hidden';
+    readonly control: FixedInputControl['kind'];
+    readonly label?: string;
+    readonly choices?: FixedInputControl['choices'];
+    readonly reset?: JsonValue;
+    readonly valueType?: 'number' | 'string';
+    readonly reason?: string;
+    readonly rawDisplay?: string;
+    readonly unverified?: true;
+}
+export interface FixedInputBranchState {
+    readonly selector: string;
+    readonly status: 'known' | 'alias' | 'unknown' | 'reporter' | 'unsupported' | 'missing';
+    readonly value?: string;
+}
+export interface FixedInputViewDescription {
+    readonly inputs: Readonly<Record<string, FixedInputViewInput>>;
+    readonly issues: readonly ValidationIssue[];
+    readonly branches: readonly FixedInputBranchState[];
+}
+export interface FixedInputDeclaration {
+    readonly contractId: string;
+    readonly contractRevision: string;
+    readonly editableArguments: readonly string[];
+    readonly readOnlyArguments: readonly string[];
+    readonly dependencies: readonly FixedInputDependency[];
+    readonly branchRules?: readonly FixedInputBranchRule[];
+}
+/** Host-owned field identity only; live VM and Blockly objects never cross this port. */
+export interface FixedInputMetadata {
+    readonly role: 'editable' | 'readonly';
+    readonly source: 'shadow' | 'field' | 'reporter' | 'unsupported' | 'missing';
+    readonly identity: string;
+    readonly field?: {
+        readonly blockId: string;
+        readonly name: string;
+        readonly type: string;
+    };
+    readonly reason?: string;
+}
+export interface FixedBlockSnapshot extends BlockSnapshot {
+    readonly fixedContext: {
+        readonly contractId: string;
+        readonly contractRevision: string;
+        readonly generation: string;
+        readonly readOnlyArguments: readonly string[];
+        readonly dependencies: readonly FixedInputDependency[];
+        readonly inputs: Readonly<Record<string, FixedInputMetadata>>;
+    };
+}
+/** The form projection never replaces the raw literals retained in the snapshot. */
+export type FixedInputDraftEntry = {
+    readonly value: JsonValue;
+    readonly changed: boolean;
+    readonly buffer?: string;
+    readonly repair?: true;
+} | {
+    readonly readOnly: true;
+};
+export interface FixedInputDraft extends JsonObject {
+    readonly inputs: Readonly<Record<string, FixedInputDraftEntry>>;
+}
+export type FixedPreparedSave<C = null> = {
+    readonly kind: 'ready';
+    readonly changes: readonly LiteralArgumentChange[];
+    readonly context: SchemaValidationContext<C>;
+} | {
+    readonly kind: 'invalid';
+    readonly issues: readonly ValidationIssue[];
+};
+export interface FixedInputEditorDefinition<C = null> extends EditorDefinition, FixedInputDeclaration {
+    readonly saveContract: 'prepared-fixed-v1';
+    readFixed(snapshot: FixedBlockSnapshot): JsonObject;
+    prepareFixedSave(draft: JsonObject, snapshot: FixedBlockSnapshot): FixedPreparedSave<C>;
+    describeFixed?(draft: JsonObject, snapshot: FixedBlockSnapshot): FixedInputViewDescription;
+}
+export interface FixedCommitRequest<C = null> {
+    readonly expected: FixedBlockSnapshot;
+    readonly changes: readonly LiteralArgumentChange[];
+    readonly context: SchemaValidationContext<C>;
+    readonly signal: AbortSignal;
+}
+/** Erase owner settings to JSON, never to unknown (whose JsonSettings type is never). */
+export interface FixedHostCommitRequest extends Omit<FixedCommitRequest, 'context'> {
+    readonly context: {
+        readonly consumerId: string;
+        readonly nowMs: number;
+        readonly settings: SchemaJsonValue;
+    };
+}
+export interface FixedInputEditorHost {
+    readonly capability: typeof FIXED_INPUTS_CAPABILITY;
+    /** Include editable inputs and read-only dependencies without evaluating reporters. */
+    readBlock(reference: BlockReference, declaration: FixedInputDeclaration): FixedBlockSnapshot | null;
+    /** Recheck all identities and dependencies at the actual atomic write boundary. */
+    commit(request: FixedHostCommitRequest): void | Promise<void>;
+    /** Optional lifetime notification; ordinary same-scope edits remain save-time conflicts. */
+    subscribeInvalidation?(reference: BlockReference, declaration: FixedInputDeclaration, listener: (error: unknown) => void): () => void;
+}
+/** Inspect methods without evaluating accessor-backed capability advertisements. */
+export declare function supportsFixedInputs(host: BlockEditorHost): host is BlockEditorHost & {
+    fixedInputs: FixedInputEditorHost;
+};
+export declare const supportsFixedInputEditing: typeof supportsFixedInputs;

package/dist/fixed-input-types.js

@@ -0,0 +1,23 @@
+export const FIXED_INPUTS_CAPABILITY = 'fixed-inputs-v1';
+/** Inspect methods without evaluating accessor-backed capability advertisements. */
+export function supportsFixedInputs(host) {
+    const data = (object, key) => {
+        let item = object;
+        for (let depth = 0; item && (typeof item === 'object' || typeof item === 'function') && depth < 64; depth++) {
+            const descriptor = Object.getOwnPropertyDescriptor(item, key);
+            if (descriptor)
+                return 'value' in descriptor ? descriptor.value : undefined;
+            item = Object.getPrototypeOf(item);
+        }
+        return undefined;
+    };
+    try {
+        const port = data(host, 'fixedInputs');
+        return data(port, 'capability') === FIXED_INPUTS_CAPABILITY &&
+            typeof data(port, 'readBlock') === 'function' && typeof data(port, 'commit') === 'function';
+    }
+    catch (_a) {
+        return false;
+    }
+}
+export const supportsFixedInputEditing = supportsFixedInputs;

package/dist/fixed-input-view.d.ts

@@ -0,0 +1,14 @@
+import type { EditorViewContext } from './types.js';
+export interface FixedInputViewMessages {
+    readonly reset: string;
+    readonly readOnly: string;
+    readonly unverified: string;
+    readonly currentValue: string;
+    readonly colorPicker: string;
+    readonly invalidValue: string;
+    readonly inactiveDraft: string;
+}
+export type FixedInputMessageSource = Partial<FixedInputViewMessages> | (() => Partial<FixedInputViewMessages>);
+export declare function captureFixedInputMessages(input?: Partial<FixedInputViewMessages>): FixedInputViewMessages;
+export declare function resolveFixedInputMessages(source?: FixedInputMessageSource): FixedInputViewMessages;
+export declare function mountFixedInputView(container: HTMLElement, context: EditorViewContext, messages?: FixedInputViewMessages): () => void;

package/dist/fixed-input-view.js

@@ -0,0 +1,168 @@
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import { parseFixedNumberInput } from './fixed-input-schema.js';
+const defaultMessages = Object.freeze({
+    reset: 'Reset', readOnly: 'This input cannot be edited safely.',
+    unverified: 'The expression is retained without evaluation. Its runtime validity has not been checked.',
+    currentValue: 'Current value', colorPicker: 'color picker', invalidValue: 'Check this value before saving.',
+    inactiveDraft: 'Hidden edits are retained in this dialog and will not be saved while hidden.'
+});
+export function captureFixedInputMessages(input) {
+    if (input === undefined)
+        return defaultMessages;
+    if (!input || typeof input !== 'object' || Array.isArray(input) ||
+        (Object.getPrototypeOf(input) !== Object.prototype && Object.getPrototypeOf(input) !== null) || Object.getOwnPropertySymbols(input).length)
+        throw new TypeError('Invalid fixed form messages.');
+    const result = { ...defaultMessages };
+    for (const key of Object.getOwnPropertyNames(input)) {
+        const descriptor = Object.getOwnPropertyDescriptor(input, key);
+        if (!Object.hasOwn(defaultMessages, key) || !('value' in descriptor) || typeof descriptor.value !== 'string' || !descriptor.value)
+            throw new TypeError('Invalid fixed form messages.');
+        Object.defineProperty(result, key, { value: descriptor.value, enumerable: true });
+    }
+    return Object.freeze(result);
+}
+export function resolveFixedInputMessages(source) {
+    const value = typeof source === 'function' ? source() : source;
+    try {
+        return captureFixedInputMessages(value);
+    }
+    catch (error) {
+        try {
+            void Promise.prototype.then.call(value, () => undefined, () => undefined);
+        }
+        catch ( /* UI providers are synchronous; never inspect thenables. */_a) { /* UI providers are synchronous; never inspect thenables. */ }
+        throw error;
+    }
+}
+const record = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const display = (value) => typeof value === 'string' ? value
+    : typeof value === 'number' && Object.is(value, -0) ? '-0' : value === undefined ? '' : JSON.stringify(value);
+const serialized = (value) => value === undefined ? 'unavailable' : JSON.stringify(value);
+function preview(value) {
+    if (/^#[\da-f]{6}$/iu.test(value))
+        return value.toLowerCase();
+    return /^#[\da-f]{3}$/iu.test(value) ? `#${value.slice(1).split('').map(part => part + part).join('').toLowerCase()}` : undefined;
+}
+function describe(context) {
+    if (typeof context.getFixedInputView !== 'function')
+        throw new TypeError('A fixed form requires a fixed session.');
+    const result = context.getFixedInputView();
+    if (!result)
+        throw new TypeError('A fixed form requires a fixed session.');
+    return result;
+}
+let nextFixedViewId = 0;
+/** The session owns every buffer, including controls temporarily absent from the DOM. */
+function FixedInputView({ context, messages }) {
+    const [, redraw] = React.useState(0);
+    const [viewId] = React.useState(() => `block-editor-fixed-${++nextFixedViewId}`);
+    React.useEffect(() => {
+        const stop = context.subscribe(() => redraw(value => value + 1));
+        if (context.getState().status === 'editing' && !context.getState().issues.length) {
+            context.setValidationIssues(describe(context).issues);
+        }
+        return stop;
+    }, [context]);
+    const state = context.getState();
+    if (state.status !== 'editing' && state.status !== 'saving')
+        return React.createElement(React.Fragment, null);
+    const description = describe(context);
+    const draft = context.getDraft();
+    const inputs = record(draft.inputs) ? draft.inputs : {};
+    const update = (argument, value, buffer) => {
+        if (context.getState().status !== 'editing')
+            return;
+        const latest = describe(context).inputs[argument];
+        if (!latest || latest.state !== 'editable')
+            return;
+        const next = context.getDraft();
+        if (!record(next.inputs))
+            throw new TypeError('Invalid fixed form draft.');
+        const previous = next.inputs[argument];
+        const entry = { value, changed: true };
+        if (buffer !== undefined)
+            entry.buffer = buffer;
+        if (record(previous) && (previous.readOnly === true || previous.repair === true))
+            entry.repair = true;
+        Object.defineProperty(next.inputs, argument, { value: entry, enumerable: true, configurable: true, writable: true });
+        context.setDraft(next);
+        context.setValidationIssues(describe(context).issues);
+    };
+    const hasInactiveEdits = Object.entries(description.inputs).some(([argument, input]) => input.state === 'hidden' && record(inputs[argument]) && inputs[argument].changed === true);
+    return React.createElement("div", { className: "block-editor-fixed-inputs" },
+        hasInactiveEdits && React.createElement("p", { className: "block-editor-fixed-inactive", "data-fixed-inactive-draft": "", role: "status" }, messages.inactiveDraft),
+        Object.entries(description.inputs).map(([argument, input], index) => {
+            var _a, _b, _c, _d, _e;
+            if (input.state === 'hidden')
+                return null;
+            const entry = record(inputs[argument]) ? inputs[argument] : {};
+            const value = Object.hasOwn(entry, 'value') ? entry.value : undefined;
+            const label = (_a = input.label) !== null && _a !== void 0 ? _a : argument;
+            const text = typeof entry.buffer === 'string' ? entry.buffer : value === undefined ? (_b = input.rawDisplay) !== null && _b !== void 0 ? _b : '' : display(value);
+            const disabled = state.status !== 'editing' || input.state !== 'editable';
+            const path = `/${argument.replace(/~/g, '~0').replace(/\//g, '~1')}`;
+            const invalid = [...state.issues, ...description.issues].some(issue => { var _a; return issue.path === path || ((_a = issue.path) === null || _a === void 0 ? void 0 : _a.startsWith(`${path}/`)); });
+            const errorId = `${viewId}-${index}-error`;
+            const reasonId = `${viewId}-${index}-reason`;
+            const unverifiedId = `${viewId}-${index}-unverified`;
+            const originalId = `${viewId}-${index}-original`;
+            const showOriginal = input.control === 'enum' && input.rawDisplay !== undefined && entry.changed !== true && input.rawDisplay !== display(value);
+            const descriptions = [input.state === 'readonly' ? reasonId : '', invalid ? errorId : '', input.unverified ? unverifiedId : '', showOriginal ? originalId : ''].filter(Boolean).join(' ');
+            const attributes = { 'aria-invalid': invalid || undefined, 'data-block-editor-invalid': invalid ? 'true' : undefined,
+                'aria-describedby': descriptions || undefined };
+            let control;
+            if (input.state === 'readonly') {
+                control = React.createElement(React.Fragment, null,
+                    React.createElement("output", { "aria-label": label, ...attributes }, (_c = input.rawDisplay) !== null && _c !== void 0 ? _c : text),
+                    React.createElement("p", { id: reasonId, className: "block-editor-fixed-readonly" }, messages.readOnly));
+            }
+            else if (input.control === 'enum') {
+                const choices = (_d = input.choices) !== null && _d !== void 0 ? _d : [];
+                const current = serialized(value);
+                const known = choices.some(choice => serialized(choice.value) === current);
+                control = React.createElement("select", { "aria-label": label, ...attributes, value: known ? current : 'existing-raw', disabled: disabled, onChange: event => {
+                        const choice = choices.find(item => serialized(item.value) === event.target.value);
+                        if (choice)
+                            update(argument, choice.value);
+                    } },
+                    !known && React.createElement("option", { value: "existing-raw", disabled: true }, ((_e = input.rawDisplay) !== null && _e !== void 0 ? _e : text) || messages.currentValue),
+                    choices.map((choice, index) => { var _a; return React.createElement("option", { key: index, value: serialized(choice.value) }, (_a = choice.label) !== null && _a !== void 0 ? _a : display(choice.value)); }));
+            }
+            else if (input.control === 'number') {
+                control = React.createElement("input", { "aria-label": label, ...attributes, type: "text", inputMode: "decimal", value: text, disabled: disabled, onChange: event => {
+                        const buffer = event.target.value;
+                        if (input.valueType === 'string' || (input.valueType === undefined && typeof value === 'string')) {
+                            update(argument, buffer);
+                        }
+                        else {
+                            const parsed = parseFixedNumberInput(buffer);
+                            update(argument, parsed.kind === 'valid' ? parsed.value : value !== null && value !== void 0 ? value : null, buffer);
+                        }
+                    } });
+            }
+            else if (input.control === 'color') {
+                const color = preview(text);
+                control = React.createElement("div", { className: "block-editor-fixed-color" },
+                    React.createElement("input", { "aria-label": label, ...attributes, type: "text", value: text, disabled: disabled, onChange: event => update(argument, event.target.value) }),
+                    color !== undefined && React.createElement("input", { type: "color", "aria-label": `${label} ${messages.colorPicker}`, ...attributes, value: color, disabled: disabled, onChange: event => update(argument, event.target.value) }));
+            }
+            else
+                control = React.createElement("textarea", { "aria-label": label, ...attributes, value: text, disabled: disabled, onChange: event => update(argument, event.target.value) });
+            return React.createElement("fieldset", { key: argument, "data-fixed-argument": argument, disabled: disabled },
+                React.createElement("legend", null, label),
+                control,
+                input.state === 'editable' && input.reset !== undefined && React.createElement("button", { type: "button", disabled: disabled, "aria-label": `${label} ${messages.reset}`, onClick: () => update(argument, input.reset) }, messages.reset),
+                showOriginal && React.createElement("p", { id: originalId, className: "block-editor-fixed-original", "data-fixed-original-value": "" },
+                    messages.currentValue,
+                    ': ',
+                    React.createElement("output", null, input.rawDisplay)),
+                invalid && React.createElement("p", { id: errorId, className: "block-editor-fixed-error" }, messages.invalidValue),
+                input.unverified && React.createElement("p", { id: unverifiedId, className: "block-editor-fixed-unverified" }, messages.unverified));
+        }));
+}
+export function mountFixedInputView(container, context, messages = defaultMessages) {
+    describe(context);
+    ReactDOM.render(React.createElement(FixedInputView, { context: context, messages: messages }), container);
+    return () => { ReactDOM.unmountComponentAtNode(container); };
+}

package/dist/index.d.ts

@@ -4,3 +4,9 @@ export { EditorSession } from './session.js';
 export * from './descendant-types.js';
 export { DescendantSession } from './descendants.js';
 export type * from './prepared-types.js';
+export { parseFixedNumberInput } from './fixed-input-schema.js';
+export type { FixedNumberInputResult } from './fixed-input-schema.js';
+export * from './fixed-input-types.js';
+export { captureFixedInputDeclaration, captureFixedSnapshot, sameFixedSnapshot } from './fixed-input-snapshot.js';
+export { createFixedInputEditor } from './fixed-input-editor.js';
+export type { FixedInputBinding, FixedInputBranchPolicy, FixedInputEditorOptions } from './fixed-input-editor.js';

package/dist/index.js

@@ -3,3 +3,7 @@ export { EditorRegistry } from './registry.js';
 export { EditorSession } from './session.js';
 export * from './descendant-types.js';
 export { DescendantSession } from './descendants.js';
+export { parseFixedNumberInput } from './fixed-input-schema.js';
+export * from './fixed-input-types.js';
+export { captureFixedInputDeclaration, captureFixedSnapshot, sameFixedSnapshot } from './fixed-input-snapshot.js';
+export { createFixedInputEditor } from './fixed-input-editor.js';