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

package/dist/react.css

@@ -8,6 +8,31 @@
     width: min(900px, calc(100vw - 32px));
 }
 
+.modal-content .header {
+    height: auto;
+    min-height: 3.5rem;
+    align-items: center;
+}
+
+.modal-content .header > div:first-child {
+    flex: 1 1 0;
+    min-width: 0;
+    margin: 0;
+    overflow-wrap: anywhere;
+    text-align: center;
+}
+
+.modal-content .header > div:last-child {
+    flex: 0 0 auto;
+}
+
+.modal-content .header img {
+    flex-shrink: 0;
+    width: 1.75rem;
+    height: 1.75rem;
+    object-fit: contain;
+}
+
 .tree {
     min-width: 0;
 }
@@ -152,6 +177,107 @@
     margin-bottom: 1rem;
 }
 
+.body :global([data-block-editor-item]) {
+    box-sizing: border-box;
+    min-width: 0;
+    margin: 0.75rem 0;
+    padding: 1rem;
+    border: 1px solid var(--block-editor-border, rgba(0, 0, 0, 0.15));
+    border-radius: var(--block-editor-radius, 0.5rem);
+}
+
+.body :global([data-block-editor-item-heading]),
+.body :global([data-block-editor-item-actions]) {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.body :global([data-block-editor-item-heading]) {
+    justify-content: space-between;
+    margin-bottom: 0.75rem;
+    font-weight: bold;
+}
+
+.body :global([data-block-editor-item]) input,
+.body :global([data-block-editor-item]) select,
+.body :global([data-block-editor-item]) textarea {
+    box-sizing: border-box;
+}
+
+.body :global([data-block-editor-pair-row]) {
+    display: grid;
+    grid-template-columns: 3rem minmax(0, 1fr);
+    align-items: center;
+    gap: 0.5rem 0.75rem;
+    margin-top: 0.5rem;
+}
+
+.body :global([data-block-editor-pair-row]) > label {
+    grid-column: 1;
+    margin: 0;
+}
+
+.body :global([data-block-editor-pair-row]) > :not(label) {
+    grid-column: 2;
+    min-width: 0;
+}
+
+.body :global([data-block-editor-pair-row]) input:not([type="checkbox"]):not([type="radio"]),
+.body :global([data-block-editor-pair-row]) select,
+.body :global([data-block-editor-pair-row]) textarea {
+    margin-top: 0;
+}
+
+.body :global([data-block-editor-item-actions]) button,
+.body :global([data-block-editor-item-menu]) button,
+.body :global([data-block-editor-add-item]) {
+    min-height: 2.25rem;
+    padding: 0.5rem 0.75rem;
+    border: 1px solid var(--block-editor-border, rgba(0, 0, 0, 0.15));
+    border-radius: var(--block-editor-radius, 0.5rem);
+    color: var(--block-editor-text, #333);
+    background: var(--block-editor-button, white);
+    cursor: pointer;
+    font: inherit;
+}
+
+.body :global([data-block-editor-item-menu]) {
+    position: relative;
+    flex-shrink: 0;
+}
+
+.body :global([data-block-editor-item-menu]) :global([role="menu"]) {
+    position: absolute;
+    inset-inline-end: 0;
+    top: 100%;
+    z-index: 1;
+    min-width: max-content;
+    padding: 0.25rem;
+    background: var(--block-editor-background, white);
+    border: 1px solid var(--block-editor-border, rgba(0, 0, 0, 0.15));
+    border-radius: var(--block-editor-radius, 0.5rem);
+    box-shadow: 0 3px 10px rgba(0, 0, 0, 0.15);
+}
+
+.body :global([data-block-editor-item-menu]) :global([role="menuitem"]) {
+    width: 100%;
+    border: 0;
+    text-align: start;
+}
+
+.body :global([data-block-editor-item-actions]) button:disabled,
+.body :global([data-block-editor-add-item]):disabled {
+    opacity: 0.5;
+    cursor: default;
+}
+
+.body :global([data-block-editor-item-menu]) button:focus-visible,
+.body :global([data-block-editor-add-item]):focus-visible {
+    outline: 2px solid currentColor;
+    outline-offset: 2px;
+}
+
 /* The adapter marks only controls belonging to the field's own RJSF errors. */
 .body :global(.rjsf) input:global([data-block-editor-invalid="true"]),
 .body :global(.rjsf) select:global([data-block-editor-invalid="true"]),
@@ -181,3 +307,45 @@
     outline: 2px solid currentColor;
     outline-offset: 2px;
 }
+
+.body :global(.block-editor-fixed-inputs) > fieldset {
+    margin: 0 0 1rem;
+    padding: 0.75rem;
+    border: 1px solid var(--block-editor-border, #ccc);
+    border-radius: var(--block-editor-radius, 0.5rem);
+}
+
+.body :global(.block-editor-fixed-inputs) output {
+    white-space: pre-wrap;
+    overflow-wrap: anywhere;
+}
+
+.body :global(.block-editor-fixed-color) {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.body :global(.block-editor-fixed-color) input[type="text"] {
+    flex: 1;
+    min-width: 0;
+}
+
+.body :global(.block-editor-fixed-color) input[type="color"] {
+    width: 3rem;
+    min-width: 3rem;
+    height: 2.75rem;
+    padding: 0.25rem;
+    box-sizing: border-box;
+}
+
+.body :global(.block-editor-fixed-readonly),
+.body :global(.block-editor-fixed-unverified) {
+    margin-bottom: 0;
+    font-size: 0.875em;
+}
+
+.body :global(.block-editor-fixed-error) {
+    color: var(--block-editor-error-text, #a61b1b);
+    margin-bottom: 0;
+}

package/dist/react.d.ts

@@ -10,7 +10,11 @@ export interface DialogSessionState {
     readonly error: unknown;
 }
 export interface DialogSession {
+    readonly reference?: {
+        readonly blockId: string;
+    };
     getState(): DialogSessionState;
+    getFixedInputView?(): unknown;
     subscribe(listener: () => void): () => void;
     mount?(container: HTMLElement): () => void;
     getNodes?(): readonly DescendantNodeDescriptor[];
@@ -29,6 +33,8 @@ export interface EditorDialogMessages {
     readonly conflict: string;
     readonly failed: string;
     readonly structuralNode: string;
+    /** Fixed forms retain technical diagnostics in the API while showing a localized summary. */
+    readonly invalidInput?: string;
 }
 export interface EditorNodeAppearance {
     readonly name?: string;
@@ -40,6 +46,8 @@ export interface EditorModalProps {
     readonly id: string;
     readonly className: string;
     readonly contentLabel: string;
+    readonly headerImage?: string;
+    readonly headerClassName?: string | undefined;
     readonly onRequestClose: () => void;
     readonly children?: React.ReactNode;
 }

package/dist/react.js

@@ -203,10 +203,27 @@ export class BlockEditorDialog extends React.Component {
         }
     }
     render() {
+        var _a, _b, _c, _d;
         const { styles, messages, ModalComponent, session } = this.props;
         const saving = this.state.status === 'saving';
         const hierarchy = typeof session.getNodes === 'function';
-        return React.createElement(ModalComponent, { className: `${styles.modalContent || ''} ${hierarchy ? styles.hierarchyModal : ''} ${this.props.className || ''}`, contentLabel: messages.title, id: "blockEditorModal", onRequestClose: this.handleClose },
+        let fixed = false;
+        if (session.getFixedInputView && (this.state.status === 'editing' || saving)) {
+            try {
+                fixed = Boolean(session.getFixedInputView());
+            }
+            catch (_e) {
+                fixed = true;
+            }
+        }
+        const root = (_a = session.getNodes) === null || _a === void 0 ? void 0 : _a.call(session).find(node => node.inputPath.length === 0);
+        const rootId = ((_b = session.reference) === null || _b === void 0 ? void 0 : _b.blockId) || (root === null || root === void 0 ? void 0 : root.reference.blockId);
+        const appearance = rootId ? (_c = this.props.nodeAppearances) === null || _c === void 0 ? void 0 : _c[rootId] : undefined;
+        const name = (appearance === null || appearance === void 0 ? void 0 : appearance.name) || (rootId ? (_d = this.props.nodeLabels) === null || _d === void 0 ? void 0 : _d[rootId] : undefined) || (root === null || root === void 0 ? void 0 : root.opcode);
+        const title = name ? messages.title.includes('{name}') ? messages.title.replace('{name}', () => name) :
+            /ブロック|block/i.test(messages.title) ? messages.title.replace(/ブロック|block/i, () => name) :
+                `${name}: ${messages.title}` : messages.title;
+        return React.createElement(ModalComponent, { className: `${styles.modalContent || ''} ${hierarchy ? styles.hierarchyModal : ''} ${this.props.className || ''}`, contentLabel: title, ...((appearance === null || appearance === void 0 ? void 0 : appearance.iconURI) ? { headerImage: appearance.iconURI } : {}), headerClassName: styles.header, id: "blockEditorModal", onRequestClose: this.handleClose },
             React.createElement("div", { "aria-busy": saving, className: styles.body, onCompositionStart: () => { this.composing = true; }, onCompositionEnd: () => { this.composing = false; }, onKeyDownCapture: event => {
                     if (this.composing || event.nativeEvent.isComposing || event.keyCode === 229)
                         event.stopPropagation();
@@ -215,7 +232,7 @@ export class BlockEditorDialog extends React.Component {
                     React.createElement("div", { ref: this.handleBody }, hierarchy ? React.createElement(DescendantTree, { session: session, styles: styles, messages: messages, disabled: saving, nodeAppearances: this.props.nodeAppearances, nodeLabels: this.props.nodeLabels, onError: this.handleMountError, ref: tree => { this.tree = tree; } }) : null),
                     React.createElement("div", { "aria-live": "polite", className: styles.errors, role: "status" },
                         saving ? messages.saving : null,
-                        this.state.issues.map((issue, index) => {
+                        fixed && this.state.issues.length ? React.createElement("p", null, messages.invalidInput || messages.failed) : this.state.issues.map((issue, index) => {
                             var _a;
                             return hierarchy && 'reference' in issue ?
                                 React.createElement("button", { className: styles.nodeError, "data-block-editor-issue": index, disabled: saving, key: index, type: "button", onClick: () => { var _a; return (_a = this.tree) === null || _a === void 0 ? void 0 : _a.reveal(issue); } },

package/dist/registry.d.ts

@@ -3,11 +3,15 @@ import { DescendantSession } from './descendants.js';
 import type { DescendantLimits } from './descendant-types.js';
 import type { BlockEditorHost, BlockReference, EditorDefinition, EditorDescriptor } from './types.js';
 import type { PreparedEditorDefinition } from './prepared-types.js';
+import type { FixedInputDeclaration, FixedInputEditorDefinition } from './fixed-input-types.js';
 export declare class EditorRegistry {
     #private;
     register(definition: EditorDefinition): () => void;
     registerPrepared(definition: PreparedEditorDefinition): () => void;
+    registerFixed<C = null>(definition: FixedInputEditorDefinition<C>): () => void;
     resolve(opcode: string): EditorDescriptor | undefined;
+    /** Stable, callback-free authority for this exact registration, never caller metadata. */
+    resolveFixed(opcode: string): FixedInputDeclaration | undefined;
     open(reference: BlockReference, host: BlockEditorHost): EditorSession | undefined;
     openDescendants(reference: BlockReference, host: BlockEditorHost, limits?: DescendantLimits): DescendantSession | undefined;
 }

package/dist/registry.js

@@ -3,7 +3,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _EditorRegistry_instances, _EditorRegistry_editors, _EditorRegistry_opcodes, _EditorRegistry_changes, _EditorRegistry_register, _EditorRegistry_notifyChanges;
+var _EditorRegistry_instances, _EditorRegistry_editors, _EditorRegistry_opcodes, _EditorRegistry_fixedDeclarations, _EditorRegistry_changes, _EditorRegistry_register, _EditorRegistry_notifyChanges;
 import { captureReference, captureSnapshot } from './data.js';
 import { EditorSession } from './session.js';
 import { DescendantSession } from './descendants.js';
@@ -11,14 +11,20 @@ import { supportsDescendantEditing } from './descendant-types.js';
 import { captureSubtree, descendantLimits } from './subtree.js';
 import { EDITOR_API_VERSION } from './types.js';
 import { isPreparedEditor } from './prepared-save.js';
+import { isFixedInputEditor, captureFixedInputEditorDefinition } from './fixed-input-editor.js';
+import { captureFixedInputDeclaration, captureFixedSnapshot } from './fixed-input-snapshot.js';
+import { supportsFixedInputEditing } from './fixed-input-types.js';
 export class EditorRegistry {
     constructor() {
         _EditorRegistry_instances.add(this);
         _EditorRegistry_editors.set(this, new Map());
         _EditorRegistry_opcodes.set(this, new Map());
+        _EditorRegistry_fixedDeclarations.set(this, new Map());
         _EditorRegistry_changes.set(this, new Set());
     }
     register(definition) {
+        if (isFixedInputEditor(definition))
+            throw new TypeError('Fixed input editors require registerFixed().');
         if (isPreparedEditor(definition))
             throw new TypeError('Prepared editors require registerPrepared().');
         return __classPrivateFieldGet(this, _EditorRegistry_instances, "m", _EditorRegistry_register).call(this, definition);
@@ -29,6 +35,9 @@ export class EditorRegistry {
         }
         return __classPrivateFieldGet(this, _EditorRegistry_instances, "m", _EditorRegistry_register).call(this, definition);
     }
+    registerFixed(definition) {
+        return __classPrivateFieldGet(this, _EditorRegistry_instances, "m", _EditorRegistry_register).call(this, captureFixedInputEditorDefinition(definition));
+    }
     resolve(opcode) {
         const entry = __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(opcode);
         if (!entry)
@@ -38,15 +47,37 @@ export class EditorRegistry {
             opcodes: entry.opcodes, editableArguments: entry.editableArguments
         });
     }
+    /** Stable, callback-free authority for this exact registration, never caller metadata. */
+    resolveFixed(opcode) {
+        const entry = __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(opcode);
+        return entry ? __classPrivateFieldGet(this, _EditorRegistry_fixedDeclarations, "f").get(entry) : undefined;
+    }
     open(reference, host) {
         const capturedReference = captureReference(reference);
         const live = host.readBlock(capturedReference);
         if (!live)
             return undefined;
+        const entry = __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(live.opcode);
+        if (!entry) {
+            // Preserve legacy snapshot validation even when no editor is registered.
+            captureSnapshot(live, capturedReference);
+            return undefined;
+        }
+        if (isFixedInputEditor(entry)) {
+            if (!supportsFixedInputEditing(host))
+                return undefined;
+            const fixed = host.fixedInputs.readBlock(capturedReference, entry);
+            if (!fixed || fixed.opcode !== live.opcode)
+                return undefined;
+            const snapshot = captureFixedSnapshot(fixed, capturedReference, entry);
+            return new EditorSession(entry, snapshot, host, () => __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(snapshot.opcode) === entry, listener => {
+                __classPrivateFieldGet(this, _EditorRegistry_changes, "f").add(listener);
+                return () => { __classPrivateFieldGet(this, _EditorRegistry_changes, "f").delete(listener); };
+            });
+        }
         const snapshot = captureSnapshot(live, capturedReference);
-        const entry = __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(snapshot.opcode);
-        return entry ? new EditorSession(entry, snapshot, host, isPreparedEditor(entry)
-            ? () => __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(snapshot.opcode) === entry : undefined) : undefined;
+        return new EditorSession(entry, snapshot, host, isPreparedEditor(entry)
+            ? () => __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(snapshot.opcode) === entry : undefined);
     }
     openDescendants(reference, host, limits) {
         if (!supportsDescendantEditing(host))
@@ -58,15 +89,19 @@ export class EditorRegistry {
         if (!live)
             return undefined;
         const captured = captureSubtree(live, capturedReference, resolvedLimits);
-        if (!__classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").has(captured.snapshot.nodes[0].block.opcode))
+        const root = __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(captured.snapshot.nodes[0].block.opcode);
+        if (!root || isFixedInputEditor(root))
             return undefined;
-        return new DescendantSession(captured, port, opcode => __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(opcode), listener => {
+        return new DescendantSession(captured, port, opcode => {
+            const entry = __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").get(opcode);
+            return entry && !isFixedInputEditor(entry) ? entry : undefined;
+        }, listener => {
             __classPrivateFieldGet(this, _EditorRegistry_changes, "f").add(listener);
             return () => { __classPrivateFieldGet(this, _EditorRegistry_changes, "f").delete(listener); };
         }, resolvedLimits);
     }
 }
-_EditorRegistry_editors = new WeakMap(), _EditorRegistry_opcodes = new WeakMap(), _EditorRegistry_changes = new WeakMap(), _EditorRegistry_instances = new WeakSet(), _EditorRegistry_register = function _EditorRegistry_register(definition) {
+_EditorRegistry_editors = new WeakMap(), _EditorRegistry_opcodes = new WeakMap(), _EditorRegistry_fixedDeclarations = new WeakMap(), _EditorRegistry_changes = new WeakMap(), _EditorRegistry_instances = new WeakSet(), _EditorRegistry_register = function _EditorRegistry_register(definition) {
     if (definition.apiVersion !== EDITOR_API_VERSION)
         throw new TypeError('Unsupported editor API version.');
     if (!/^[a-z0-9]+$/i.test(definition.extensionId) ||
@@ -98,6 +133,8 @@ _EditorRegistry_editors = new WeakMap(), _EditorRegistry_opcodes = new WeakMap()
         opcodes: Object.freeze([...definition.opcodes]),
         editableArguments: Object.freeze([...definition.editableArguments])
     });
+    if (isFixedInputEditor(entry))
+        __classPrivateFieldGet(this, _EditorRegistry_fixedDeclarations, "f").set(entry, captureFixedInputDeclaration(entry));
     __classPrivateFieldGet(this, _EditorRegistry_editors, "f").set(key, entry);
     for (const opcode of entry.opcodes)
         __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").set(opcode, entry);
@@ -108,6 +145,7 @@ _EditorRegistry_editors = new WeakMap(), _EditorRegistry_opcodes = new WeakMap()
         __classPrivateFieldGet(this, _EditorRegistry_editors, "f").delete(key);
         for (const opcode of entry.opcodes)
             __classPrivateFieldGet(this, _EditorRegistry_opcodes, "f").delete(opcode);
+        __classPrivateFieldGet(this, _EditorRegistry_fixedDeclarations, "f").delete(entry);
         __classPrivateFieldGet(this, _EditorRegistry_instances, "m", _EditorRegistry_notifyChanges).call(this);
     };
 }, _EditorRegistry_notifyChanges = function _EditorRegistry_notifyChanges() {

package/dist/rjsf-templates.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import type { ArrayFieldTemplateItemType, FieldTemplateProps, IconButtonProps, ObjectFieldTemplateProps, WrapIfAdditionalTemplateProps } from '@rjsf/utils';
+/** Keep the property key out of the value's visible label. */
+export declare function valueFieldTemplate(DefaultTemplate: React.ComponentType<FieldTemplateProps>, flag: string): (props: FieldTemplateProps) => React.ReactElement;
+/** Keep RJSF's object layout while numbering each editable additional property. */
+export declare function numberedObjectTemplate(DefaultTemplate: React.ComponentType<ObjectFieldTemplateProps>, flag: string): (props: ObjectFieldTemplateProps) => React.ReactElement;
+export declare function additionalItemTemplate(flag: string): (props: WrapIfAdditionalTemplateProps) => React.ReactElement;
+/** Deletion is available only after explicitly opening the item's menu. */
+export declare function ItemMenu({ disabled, onClick }: Pick<IconButtonProps, 'disabled' | 'onClick'>): React.ReactElement;
+export declare function AddItemButton({ disabled, onClick, className }: IconButtonProps): React.ReactElement;
+export declare function ArrayItem(props: ArrayFieldTemplateItemType): React.ReactElement;

package/dist/rjsf-templates.js

@@ -0,0 +1,129 @@
+import * as React from 'react';
+const ItemNumber = React.createContext(1);
+const PropertyKey = React.createContext(undefined);
+/** Keep the property key out of the value's visible label. */
+export function valueFieldTemplate(DefaultTemplate, flag) {
+    return function ValueField(props) {
+        if (!(flag in props.schema))
+            return React.createElement(DefaultTemplate, { ...props });
+        return React.createElement(PropertyKey.Provider, { value: props.label },
+            React.createElement(DefaultTemplate, { ...props, label: "\u5024" }));
+    };
+}
+/** Keep RJSF's object layout while numbering each editable additional property. */
+export function numberedObjectTemplate(DefaultTemplate, flag) {
+    return function ObjectItems(props) {
+        let number = 0;
+        const properties = props.properties.map(property => {
+            var _a;
+            const schema = (_a = props.schema.properties) === null || _a === void 0 ? void 0 : _a[property.name];
+            if (!schema || typeof schema !== 'object' || !(flag in schema) || property.hidden)
+                return property;
+            return { ...property, content: React.createElement(ItemNumber.Provider, { key: property.name, value: ++number }, property.content) };
+        });
+        return React.createElement(DefaultTemplate, { ...props, properties: properties });
+    };
+}
+export function additionalItemTemplate(flag) {
+    return function AdditionalItem(props) {
+        const number = React.useContext(ItemNumber);
+        const propertyKey = React.useContext(PropertyKey);
+        const { id, classNames, style, children, schema, label, disabled, readonly, onKeyChange, onDropPropertyClick } = props;
+        if (!(flag in schema))
+            return React.createElement("div", { className: classNames, style: style }, children);
+        const key = propertyKey !== null && propertyKey !== void 0 ? propertyKey : label;
+        return React.createElement("div", { className: classNames, style: style, "data-block-editor-item": "" },
+            React.createElement("div", { "data-block-editor-item-heading": "" },
+                React.createElement("span", null,
+                    "\u30FB\u9805\u76EE",
+                    number),
+                React.createElement(ItemMenu, { disabled: disabled || readonly, onClick: onDropPropertyClick(key) })),
+            React.createElement("div", { "data-block-editor-pair-row": "" },
+                React.createElement("label", { htmlFor: `${id}-key` }, "\u30AD\u30FC"),
+                React.createElement("input", { id: `${id}-key`, type: "text", defaultValue: key, disabled: disabled, readOnly: readonly, onBlur: event => onKeyChange(event.target.value) })),
+            React.createElement("div", { "data-block-editor-pair-row": "" }, children));
+    };
+}
+/** Deletion is available only after explicitly opening the item's menu. */
+export function ItemMenu({ disabled, onClick }) {
+    const [open, setOpen] = React.useState(false);
+    const container = React.useRef(null);
+    const trigger = React.useRef(null);
+    const item = React.useRef(null);
+    React.useEffect(() => {
+        var _a;
+        if (!open)
+            return;
+        (_a = item.current) === null || _a === void 0 ? void 0 : _a.focus();
+        const closeOutside = (event) => {
+            var _a;
+            if (!((_a = container.current) === null || _a === void 0 ? void 0 : _a.contains(event.target)))
+                setOpen(false);
+        };
+        // RJSF and its host modal have separate React roots. Stop Escape before either root delegates it.
+        const keepEscapeInMenu = (event) => {
+            var _a;
+            if (event.key !== 'Escape' || event.isComposing || event.keyCode === 229)
+                return;
+            event.preventDefault();
+            event.stopPropagation();
+            setOpen(false);
+            (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.focus();
+        };
+        const menu = container.current;
+        menu === null || menu === void 0 ? void 0 : menu.addEventListener('keydown', keepEscapeInMenu);
+        document.addEventListener('mousedown', closeOutside);
+        return () => {
+            menu === null || menu === void 0 ? void 0 : menu.removeEventListener('keydown', keepEscapeInMenu);
+            document.removeEventListener('mousedown', closeOutside);
+        };
+    }, [open]);
+    React.useEffect(() => { if (disabled)
+        setOpen(false); }, [disabled]);
+    return React.createElement("div", { "data-block-editor-item-menu": "", ref: container, onBlur: event => {
+            if (!event.currentTarget.contains(event.relatedTarget))
+                setOpen(false);
+        }, onKeyDown: event => {
+            var _a, _b;
+            if (event.key === 'Escape' && open && !event.nativeEvent.isComposing && event.keyCode !== 229) {
+                event.preventDefault();
+                event.stopPropagation();
+                setOpen(false);
+                (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.focus();
+            }
+            else if (['ArrowDown', 'ArrowUp', 'Home', 'End'].includes(event.key)) {
+                event.preventDefault();
+                if (open)
+                    (_b = item.current) === null || _b === void 0 ? void 0 : _b.focus();
+                else if (!disabled)
+                    setOpen(true);
+            }
+        } },
+        React.createElement("button", { "aria-label": "\u9805\u76EE\u306E\u30E1\u30CB\u30E5\u30FC", "aria-haspopup": "menu", "aria-expanded": open && !disabled, disabled: disabled, ref: trigger, type: "button", onClick: () => setOpen(!open) }, "\u2026"),
+        open && !disabled ? React.createElement("div", { role: "menu", "aria-label": "\u9805\u76EE\u306E\u64CD\u4F5C" },
+            React.createElement("button", { ref: item, role: "menuitem", type: "button", onClick: event => {
+                    var _a;
+                    setOpen(false);
+                    (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.focus();
+                    onClick === null || onClick === void 0 ? void 0 : onClick(event);
+                } }, "\uD83D\uDDD1\uFE0F\u3053\u306E\u9805\u76EE\u3092\u524A\u9664")) : null);
+}
+export function AddItemButton({ disabled, onClick, className }) {
+    return React.createElement("button", { className: className, "data-block-editor-add-item": "", disabled: disabled, type: "button", onClick: onClick }, "\u2795\u9805\u76EE\u3092\u8FFD\u52A0");
+}
+export function ArrayItem(props) {
+    const { children, className, disabled, readonly, index, hasMoveUp, hasMoveDown, hasCopy, hasRemove, onReorderClick, onCopyIndexClick, onDropIndexClick } = props;
+    const locked = disabled || readonly;
+    return React.createElement("div", { className: className, "data-block-editor-item": "" },
+        React.createElement("div", { "data-block-editor-item-heading": "" },
+            React.createElement("span", null,
+                "\u30FB\u9805\u76EE",
+                index + 1),
+            React.createElement("div", { "data-block-editor-item-actions": "" },
+                hasMoveUp || hasMoveDown ? React.createElement(React.Fragment, null,
+                    React.createElement("button", { "aria-label": "\u9805\u76EE\u3092\u4E0A\u3078\u79FB\u52D5", disabled: locked || !hasMoveUp, type: "button", onClick: onReorderClick(index, index - 1) }, "\u2191"),
+                    React.createElement("button", { "aria-label": "\u9805\u76EE\u3092\u4E0B\u3078\u79FB\u52D5", disabled: locked || !hasMoveDown, type: "button", onClick: onReorderClick(index, index + 1) }, "\u2193")) : null,
+                hasCopy ? React.createElement("button", { disabled: locked, type: "button", onClick: onCopyIndexClick(index) }, "\u9805\u76EE\u3092\u8907\u88FD") : null,
+                hasRemove ? React.createElement(ItemMenu, { disabled: locked, onClick: onDropIndexClick(index) }) : null)),
+        children);
+}

package/dist/rjsf.d.ts

@@ -1,3 +1,9 @@
+import type { FixedInputMessageSource } from './fixed-input-view.js';
+export type { FixedInputViewMessages, FixedInputMessageSource } from './fixed-input-view.js';
+import type { FixedInputEditorOptions } from './fixed-input-editor.js';
+export { createFixedInputEditor } from './fixed-input-editor.js';
+export type { FixedInputEditorOptions, FixedInputBinding, FixedInputBranchPolicy } from './fixed-input-editor.js';
+export type * from './fixed-input-types.js';
 import type { SourceEditorOptions } from './source-types.js';
 export { createSourceEditor } from './source-editor.js';
 export type * from './source-types.js';
@@ -35,6 +41,7 @@ export interface BlockEditorRegistrationAPI {
     registerSchema(definition: SchemaEditorOptions): () => void;
     registerSchemaBundle?<C>(definition: SchemaBundleEditorOptions<C>): () => void;
     registerSourceEditor?<C = null>(definition: SourceEditorOptions<C>): () => void;
+    registerFixedInputEditor?<C = null>(definition: FixedInputEditorOptions<C>): () => void;
 }
 /** Capability guaranteed by the service factory, optional on a legacy host-supplied API. */
 export interface SchemaBundleBlockEditorRegistrationAPI extends BlockEditorRegistrationAPI {
@@ -44,14 +51,30 @@ export interface SchemaBundleBlockEditorRegistrationAPI extends BlockEditorRegis
 export interface SourceBlockEditorRegistrationAPI extends SchemaBundleBlockEditorRegistrationAPI {
     registerSourceEditor<C = null>(definition: SourceEditorOptions<C>): () => void;
 }
+export interface FixedBlockEditorRegistrationAPI extends SourceBlockEditorRegistrationAPI {
+    registerFixedInputEditor<C = null>(definition: FixedInputEditorOptions<C>): () => void;
+}
 export interface BlockEditorService {
     readonly registry: EditorRegistry;
     readonly api: BlockEditorRegistrationAPI;
     subscribe(listener: () => void): () => void;
 }
 /** A host owns the service's lifetime; this module never stores VM or workspace instances. */
-export declare function createBlockEditorService(): BlockEditorService & {
+export declare function createBlockEditorService(options: {
+    readonly fixedInputs: true;
+    readonly fixedInputMessages?: FixedInputMessageSource;
+}): BlockEditorService & {
+    readonly api: FixedBlockEditorRegistrationAPI;
+};
+export declare function createBlockEditorService(options?: {
+    readonly fixedInputs?: false;
+    readonly fixedInputMessages?: FixedInputMessageSource;
+}): BlockEditorService & {
     readonly api: SourceBlockEditorRegistrationAPI;
 };
+export declare function createBlockEditorService(options: {
+    readonly fixedInputs?: boolean;
+    readonly fixedInputMessages?: FixedInputMessageSource;
+}): BlockEditorService;
 /** Build an editor with JSON/YAML serialization, schema validation and the standard RJSF body. */
 export declare function createSchemaEditor(options: SchemaEditorOptions): EditorDefinition;

package/dist/rjsf.js

@@ -1,5 +1,8 @@
 import * as React from 'react';
 import { createSourceEditor } from './source-editor.js';
+import { createFixedInputEditor } from './fixed-input-editor.js';
+import { captureFixedInputMessages, resolveFixedInputMessages, mountFixedInputView } from './fixed-input-view.js';
+export { createFixedInputEditor } from './fixed-input-editor.js';
 export { createSourceEditor } from './source-editor.js';
 import * as ReactDOM from 'react-dom';
 import * as RjsfCore from '@rjsf/core';
@@ -13,6 +16,7 @@ import { cloneJson } from './data.js';
 import { decodeSource, encodeSource, sameData } from './codec.js';
 import { EditorRegistry } from './registry.js';
 import { EDITOR_API_VERSION } from './types.js';
+import { AddItemButton, ArrayItem, ItemMenu, additionalItemTemplate, numberedObjectTemplate, valueFieldTemplate } from './rjsf-templates.js';
 // RJSF v5 exposes CommonJS to Node and ESM to browser bundlers.
 function moduleExports(namespace) {
     const fallback = namespace.default;
@@ -20,8 +24,12 @@ function moduleExports(namespace) {
         ? fallback : namespace;
 }
 const Form = moduleExports(RjsfCore).default;
-const { getDefaultFormState } = moduleExports(RjsfUtils);
+const { getDefaultFormState, ADDITIONAL_PROPERTY_FLAG } = moduleExports(RjsfUtils);
 const { customizeValidator } = moduleExports(RjsfAjv);
+const defaultTemplates = moduleExports(RjsfCore).getDefaultRegistry().templates;
+const ObjectItems = numberedObjectTemplate(defaultTemplates.ObjectFieldTemplate, ADDITIONAL_PROPERTY_FLAG);
+const AdditionalItem = additionalItemTemplate(ADDITIONAL_PROPERTY_FLAG);
+const ValueField = valueFieldTemplate(defaultTemplates.FieldTemplate, ADDITIONAL_PROPERTY_FLAG);
 let nextViewId = 0;
 export function createSchemaBundleEditor(options) {
     const { schemaBundle, validationContext: provider, ownerValidate, apiVersion, extensionId, editorId, opcodes, argument, format, uiSchema, validateData } = options;
@@ -65,13 +73,30 @@ export function createSchemaBundleEditor(options) {
         ...(format === undefined ? {} : { format }), ...(uiSchema === undefined ? {} : { uiSchema }),
         ...(validateData === undefined ? {} : { validateData }) }, { issuesFor, dialect: result.validator.dialect });
 }
-/** A host owns the service's lifetime; this module never stores VM or workspace instances. */
-export function createBlockEditorService() {
+export function createBlockEditorService(options) {
+    if ((options === null || options === void 0 ? void 0 : options.fixedInputs) !== undefined && typeof options.fixedInputs !== 'boolean')
+        throw new TypeError('Invalid fixed input capability option.');
+    const messageSource = options === null || options === void 0 ? void 0 : options.fixedInputMessages;
+    const fixedMessages = typeof messageSource === 'function' ? messageSource : captureFixedInputMessages(messageSource);
     const registry = new EditorRegistry();
     const listeners = new Set();
     const notify = () => { for (const listener of [...listeners])
         listener(); };
+    const fixed = (options === null || options === void 0 ? void 0 : options.fixedInputs) === true ? {
+        registerFixedInputEditor: (definition) => {
+            const fixedDefinition = createFixedInputEditor(definition);
+            const remove = registry.registerFixed({ ...fixedDefinition, mount: (container, context) => mountFixedInputView(container, context, resolveFixedInputMessages(fixedMessages)) });
+            notify();
+            let active = true;
+            return () => { if (active) {
+                active = false;
+                remove();
+                notify();
+            } };
+        }
+    } : {};
     const api = Object.freeze({
+        ...fixed,
         apiVersion: EDITOR_API_VERSION,
         register: (definition) => {
             const custom = definition;
@@ -189,6 +214,13 @@ function createSchemaEditorImpl(options, bundle) {
                 const state = context.getState();
                 const props = {
                     schema, uiSchema, validator, idPrefix,
+                    templates: {
+                        ArrayFieldItemTemplate: ArrayItem,
+                        ObjectFieldTemplate: ObjectItems,
+                        WrapIfAdditionalTemplate: AdditionalItem,
+                        FieldTemplate: ValueField,
+                        ButtonTemplates: { AddButton: AddItemButton, RemoveButton: ItemMenu }
+                    },
                     formData: dataFor(context.getDraft()),
                     // Defaults belong to read(), not subsequent renders or remounts.
                     experimental_defaultFormStateBehavior: {