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

package/dist/webpack4/rjsf.js

@@ -1,24 +1,26 @@
 import {
   EditorRegistry,
-  cloneJson
-} from "./shared-N6YQE2X6.js";
+  cloneJson,
+  createFixedInputEditor
+} from "./shared-P2JBRZFP.js";
 import {
   EDITOR_API_VERSION
 } from "./shared-BKTRZUZH.js";
+import {
+  toValidationIssues,
+  validateSchemaInput
+} from "./shared-GQLPPRT2.js";
 import {
   compileSchemaBundle,
+  isJsonRecord,
+  parseFixedNumberInput,
   prepare,
   require__,
   require_ajv,
   require_dist,
   require_fast_uri,
-  toValidationIssues,
-  validateSchemaInput
-} from "./shared-KQOUMWJ4.js";
-import {
-  isJsonRecord,
   snapshotJson
-} from "./shared-MRPGBJIH.js";
+} from "./shared-75QIWLZY.js";
 import {
   __commonJS,
   __export,
@@ -4915,7 +4917,7 @@ var require_react_is_development = __commonJS({
         var ContextProvider = REACT_PROVIDER_TYPE;
         var Element = REACT_ELEMENT_TYPE;
         var ForwardRef = REACT_FORWARD_REF_TYPE;
-        var Fragment2 = REACT_FRAGMENT_TYPE;
+        var Fragment4 = REACT_FRAGMENT_TYPE;
         var Lazy = REACT_LAZY_TYPE;
         var Memo = REACT_MEMO_TYPE;
         var Portal = REACT_PORTAL_TYPE;
@@ -4983,7 +4985,7 @@ var require_react_is_development = __commonJS({
         exports2.ContextProvider = ContextProvider;
         exports2.Element = Element;
         exports2.ForwardRef = ForwardRef;
-        exports2.Fragment = Fragment2;
+        exports2.Fragment = Fragment4;
         exports2.Lazy = Lazy;
         exports2.Memo = Memo;
         exports2.Portal = Portal;
@@ -5025,7 +5027,7 @@ var require_react_is = __commonJS({
 });
 
 // dist/rjsf.js
-import * as React2 from "react";
+import * as React4 from "react";
 
 // node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/browser/dist/nodes/identity.js
 var ALIAS = /* @__PURE__ */ Symbol.for("yaml.alias");
@@ -11632,11 +11634,11 @@ function checkYamlKeys(node) {
   }
 }
 function yamlDocument(source) {
-  const document = parseDocument(source[0] === "\uFEFF" ? source.slice(1) : source, { keepSourceTokens: true, uniqueKeys: true, strict: true, version: "1.2", prettyErrors: false });
-  if (document.errors.length || document.warnings.length)
+  const document2 = parseDocument(source[0] === "\uFEFF" ? source.slice(1) : source, { keepSourceTokens: true, uniqueKeys: true, strict: true, version: "1.2", prettyErrors: false });
+  if (document2.errors.length || document2.warnings.length)
     fail();
-  checkYamlKeys(document.contents);
-  return document;
+  checkYamlKeys(document2.contents);
+  return document2;
 }
 function yamlValue(source) {
   return snapshot(yamlDocument(source).toJS({ maxAliasCount: 100 }));
@@ -11645,7 +11647,7 @@ function patchYaml(source, original, edited) {
   var _a;
   if (source[0] === "\uFEFF")
     return "\uFEFF" + patchYaml(source.slice(1), original, edited);
-  const document = yamlDocument(source);
+  const document2 = yamlDocument(source);
   const patches = [];
   const comments = [];
   const annotations = [];
@@ -11668,7 +11670,7 @@ function patchYaml(source, original, edited) {
     for (const child of Object.values(value))
       tokens(child);
   };
-  tokens((_a = document.contents) === null || _a === void 0 ? void 0 : _a.srcToken);
+  tokens((_a = document2.contents) === null || _a === void 0 ? void 0 : _a.srcToken);
   const remove = (start, end) => {
     if (comments.some(([a2, b2]) => a2 < end && b2 > start) || annotations.some(([a2, b2]) => a2 < end && b2 > start))
       fail();
@@ -11782,7 +11784,7 @@ function patchYaml(source, original, edited) {
       text += " ";
     patches.push({ start, end, text });
   };
-  visit3(document.contents, original, edited);
+  visit3(document2.contents, original, edited);
   return apply(source, patches);
 }
 function patchSource(source, format, original, edited) {
@@ -11939,11 +11941,11 @@ function Tree({ value, path, schema: schema4, ui, variant, invalidNumbers, chang
   const type = typeOf(value);
   let field;
   if (choices) {
-    const serialized = JSON.stringify(value);
+    const serialized2 = JSON.stringify(value);
     const options = choices.map((item) => JSON.stringify(item));
-    if (!options.includes(serialized))
-      options.unshift(serialized);
-    field = React.createElement("select", { ...props, value: serialized, onChange: (e2) => change(JSON.parse(e2.target.value)) }, options.map((item) => React.createElement("option", { key: item, value: item }, item)));
+    if (!options.includes(serialized2))
+      options.unshift(serialized2);
+    field = React.createElement("select", { ...props, value: serialized2, onChange: (e2) => change(JSON.parse(e2.target.value)) }, options.map((item) => React.createElement("option", { key: item, value: item }, item)));
   } else if (typeof value === "string") {
     field = React.createElement("textarea", { ...props, value, onChange: (e2) => change(e2.target.value) });
   } else if (typeof value === "number") {
@@ -12070,11 +12072,11 @@ function SourceView({ context, bindings }) {
     var _a, _b;
     const entry = sources[binding.argument];
     const selectedCreation = Object.hasOwn(creating, binding.argument) ? creating[binding.argument] : "";
-    let document;
+    let document2;
     let variant;
     try {
-      document = readSourceDocument(binding, entry.source);
-      variant = binding.presentationVariants.find((v2) => v2.format === document.format && v2.variantId === document.variantId);
+      document2 = readSourceDocument(binding, entry.source);
+      variant = binding.presentationVariants.find((v2) => v2.format === document2.format && v2.variantId === document2.variantId);
     } catch (_c) {
     }
     if (record2(entry.creating)) {
@@ -12089,7 +12091,7 @@ function SourceView({ context, bindings }) {
         try {
           if (entry.invalidForm === true)
             throw new TypeError();
-          const source = record2(entry.creating) ? createSourceCandidate(entry.creating.format, entry.data) : entry.mode === "form" && document && Object.hasOwn(entry, "data") ? patchDecodedSource(document, entry.data, (source2) => readSourceDocument(binding, source2)) : entry.source;
+          const source = record2(entry.creating) ? createSourceCandidate(entry.creating.format, entry.data) : entry.mode === "form" && document2 && Object.hasOwn(entry, "data") ? patchDecodedSource(document2, entry.data, (source2) => readSourceDocument(binding, source2)) : entry.source;
           const next = { ...entry, mode: "source", source, invalidForm: false, invalidNumbers: {} };
           delete next.creating;
           update(binding.argument, next);
@@ -12117,8 +12119,8 @@ function SourceView({ context, bindings }) {
         update(binding.argument, { mode: "form", source: entry.source, sourceEdited: true, creating: { format, variantId }, data: initial(type) });
       } }, "Create document (replace source)"),
       React.createElement("button", { type: "button", disabled: !variant, "aria-pressed": entry.mode === "form", onClick: () => {
-        if (document || entry.creating)
-          update(binding.argument, { ...entry, mode: "form", data: Object.hasOwn(entry, "data") ? entry.data : document.data });
+        if (document2 || entry.creating)
+          update(binding.argument, { ...entry, mode: "form", data: Object.hasOwn(entry, "data") ? entry.data : document2.data });
       } }, "Form"),
       entry.mode === "form" && React.createElement("button", { type: "button", onClick: () => {
         var _a2;
@@ -12175,14 +12177,14 @@ function createSourceCandidate(format, data) {
   const value = snapshotJson(data);
   return format === "json" ? JSON.stringify(value, null, 2) : "---\n" + stringify3(value, { version: "1.2" });
 }
-function patchDecodedSource(document, data, decode) {
-  if (document.format === "json") {
-    const body = document.source.trim();
-    const start = document.source.length - document.source.trimStart().length;
-    return document.source.slice(0, start) + patchSource(body, "json", document.data, data) + document.source.slice(start + body.length);
+function patchDecodedSource(document2, data, decode) {
+  if (document2.format === "json") {
+    const body = document2.source.trim();
+    const start = document2.source.length - document2.source.trimStart().length;
+    return document2.source.slice(0, start) + patchSource(body, "json", document2.data, data) + document2.source.slice(start + body.length);
   }
-  let candidate = patchSource(document.source, document.format, document.data, data);
-  if (decode && decode(candidate).format !== document.format) {
+  let candidate = patchSource(document2.source, document2.format, document2.data, data);
+  if (decode && decode(candidate).format !== document2.format) {
     candidate = candidate.startsWith("\uFEFF") ? "\uFEFF---\n" + candidate.slice(1) : "---\n" + candidate;
   }
   return candidate;
@@ -12353,19 +12355,19 @@ function createSourceEditor(options) {
           }
           if (validation.result.diagnostics.length)
             throw new TypeError();
-          const document = readSourceDocument(binding, candidate);
-          if (isJsonRecord(entry.creating) && (document.format !== entry.creating.format || document.variantId !== entry.creating.variantId)) {
+          const document2 = readSourceDocument(binding, candidate);
+          if (isJsonRecord(entry.creating) && (document2.format !== entry.creating.format || document2.variantId !== entry.creating.variantId)) {
             issues.push(issue("variant-unrecognized", path));
             continue;
           }
-          const validator = binding.validators.get(keyFor(document.format, document.variantId));
+          const validator = binding.validators.get(keyFor(document2.format, document2.variantId));
           if (validator) {
-            const result = validator.validate(document.data, { consumerId: context.consumerId });
+            const result = validator.validate(document2.data, { consumerId: context.consumerId });
             if (result.kind !== "valid") {
               issues.push(issue("schema-data-invalid", path));
               continue;
             }
-          } else if (entry.mode === "form" || candidate !== slot.value && !((_a2 = binding.sourceOnlyVariants) === null || _a2 === void 0 ? void 0 : _a2.some((v2) => v2.variantId === document.variantId && v2.format === document.format))) {
+          } else if (entry.mode === "form" || candidate !== slot.value && !((_a2 = binding.sourceOnlyVariants) === null || _a2 === void 0 ? void 0 : _a2.some((v2) => v2.variantId === document2.variantId && v2.format === document2.format))) {
             issues.push(issue("variant-unrecognized", path));
             continue;
           }
@@ -12381,8 +12383,200 @@ function createSourceEditor(options) {
   });
 }
 
-// dist/rjsf.js
+// dist/fixed-input-view.js
+import * as React2 from "react";
 import * as ReactDOM2 from "react-dom";
+var 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."
+});
+function captureFixedInputMessages(input) {
+  if (input === void 0)
+    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);
+}
+function resolveFixedInputMessages(source) {
+  const value = typeof source === "function" ? source() : source;
+  try {
+    return captureFixedInputMessages(value);
+  } catch (error) {
+    try {
+      void Promise.prototype.then.call(value, () => void 0, () => void 0);
+    } catch (_a) {
+    }
+    throw error;
+  }
+}
+var record3 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var display = (value) => typeof value === "string" ? value : typeof value === "number" && Object.is(value, -0) ? "-0" : value === void 0 ? "" : JSON.stringify(value);
+var serialized = (value) => value === void 0 ? "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()}` : void 0;
+}
+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;
+}
+var nextFixedViewId = 0;
+function FixedInputView({ context, messages }) {
+  const [, redraw] = React2.useState(0);
+  const [viewId] = React2.useState(() => `block-editor-fixed-${++nextFixedViewId}`);
+  React2.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 React2.createElement(React2.Fragment, null);
+  const description = describe(context);
+  const draft = context.getDraft();
+  const inputs = record3(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 (!record3(next.inputs))
+      throw new TypeError("Invalid fixed form draft.");
+    const previous = next.inputs[argument];
+    const entry = { value, changed: true };
+    if (buffer !== void 0)
+      entry.buffer = buffer;
+    if (record3(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" && record3(inputs[argument]) && inputs[argument].changed === true);
+  return React2.createElement(
+    "div",
+    { className: "block-editor-fixed-inputs" },
+    hasInactiveEdits && React2.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, _e2;
+      if (input.state === "hidden")
+        return null;
+      const entry = record3(inputs[argument]) ? inputs[argument] : {};
+      const value = Object.hasOwn(entry, "value") ? entry.value : void 0;
+      const label = (_a = input.label) !== null && _a !== void 0 ? _a : argument;
+      const text = typeof entry.buffer === "string" ? entry.buffer : value === void 0 ? (_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((issue2) => {
+        var _a2;
+        return issue2.path === path || ((_a2 = issue2.path) === null || _a2 === void 0 ? void 0 : _a2.startsWith(`${path}/`));
+      });
+      const errorId2 = `${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 !== void 0 && entry.changed !== true && input.rawDisplay !== display(value);
+      const descriptions = [input.state === "readonly" ? reasonId : "", invalid ? errorId2 : "", input.unverified ? unverifiedId : "", showOriginal ? originalId : ""].filter(Boolean).join(" ");
+      const attributes = {
+        "aria-invalid": invalid || void 0,
+        "data-block-editor-invalid": invalid ? "true" : void 0,
+        "aria-describedby": descriptions || void 0
+      };
+      let control;
+      if (input.state === "readonly") {
+        control = React2.createElement(
+          React2.Fragment,
+          null,
+          React2.createElement("output", { "aria-label": label, ...attributes }, (_c = input.rawDisplay) !== null && _c !== void 0 ? _c : text),
+          React2.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 = React2.createElement(
+          "select",
+          { "aria-label": label, ...attributes, value: known ? current : "existing-raw", disabled, onChange: (event) => {
+            const choice = choices.find((item) => serialized(item.value) === event.target.value);
+            if (choice)
+              update(argument, choice.value);
+          } },
+          !known && React2.createElement("option", { value: "existing-raw", disabled: true }, ((_e2 = input.rawDisplay) !== null && _e2 !== void 0 ? _e2 : text) || messages.currentValue),
+          choices.map((choice, index2) => {
+            var _a2;
+            return React2.createElement("option", { key: index2, value: serialized(choice.value) }, (_a2 = choice.label) !== null && _a2 !== void 0 ? _a2 : display(choice.value));
+          })
+        );
+      } else if (input.control === "number") {
+        control = React2.createElement("input", { "aria-label": label, ...attributes, type: "text", inputMode: "decimal", value: text, disabled, onChange: (event) => {
+          const buffer = event.target.value;
+          if (input.valueType === "string" || input.valueType === void 0 && 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 = React2.createElement(
+          "div",
+          { className: "block-editor-fixed-color" },
+          React2.createElement("input", { "aria-label": label, ...attributes, type: "text", value: text, disabled, onChange: (event) => update(argument, event.target.value) }),
+          color !== void 0 && React2.createElement("input", { type: "color", "aria-label": `${label} ${messages.colorPicker}`, ...attributes, value: color, disabled, onChange: (event) => update(argument, event.target.value) })
+        );
+      } else
+        control = React2.createElement("textarea", { "aria-label": label, ...attributes, value: text, disabled, onChange: (event) => update(argument, event.target.value) });
+      return React2.createElement(
+        "fieldset",
+        { key: argument, "data-fixed-argument": argument, disabled },
+        React2.createElement("legend", null, label),
+        control,
+        input.state === "editable" && input.reset !== void 0 && React2.createElement("button", { type: "button", disabled, "aria-label": `${label} ${messages.reset}`, onClick: () => update(argument, input.reset) }, messages.reset),
+        showOriginal && React2.createElement(
+          "p",
+          { id: originalId, className: "block-editor-fixed-original", "data-fixed-original-value": "" },
+          messages.currentValue,
+          ": ",
+          React2.createElement("output", null, input.rawDisplay)
+        ),
+        invalid && React2.createElement("p", { id: errorId2, className: "block-editor-fixed-error" }, messages.invalidValue),
+        input.unverified && React2.createElement("p", { id: unverifiedId, className: "block-editor-fixed-unverified" }, messages.unverified)
+      );
+    })
+  );
+}
+function mountFixedInputView(container, context, messages = defaultMessages) {
+  describe(context);
+  ReactDOM2.render(React2.createElement(FixedInputView, { context, messages }), container);
+  return () => {
+    ReactDOM2.unmountComponentAtNode(container);
+  };
+}
+
+// dist/rjsf.js
+import * as ReactDOM3 from "react-dom";
 
 // node_modules/.pnpm/@rjsf+core@5.24.13_@rjsf+utils@5.24.13_react@16.14.0__react@16.14.0/node_modules/@rjsf/core/lib/index.js
 var lib_exports2 = {};
@@ -17031,7 +17225,7 @@ function getTemplate(name, registry, uiOptions = {}) {
 // node_modules/.pnpm/@rjsf+utils@5.24.13_react@16.14.0/node_modules/@rjsf/utils/lib/getWidget.js
 var import_react_is = __toESM(require_react_is());
 import { jsx as _jsx } from "react/jsx-runtime.js";
-import { createElement as createElement2 } from "react";
+import { createElement as createElement3 } from "react";
 var widgetMap = {
   boolean: {
     checkbox: "CheckboxWidget",
@@ -17097,7 +17291,7 @@ function mergeWidgetOptions(AWidget) {
 }
 function getWidget(schema4, widget, registeredWidgets = {}) {
   const type = getSchemaType(schema4);
-  if (typeof widget === "function" || widget && import_react_is.default.isForwardRef(createElement2(widget)) || import_react_is.default.isMemo(widget)) {
+  if (typeof widget === "function" || widget && import_react_is.default.isForwardRef(createElement3(widget)) || import_react_is.default.isMemo(widget)) {
     return mergeWidgetOptions(widget);
   }
   if (typeof widget !== "string") {
@@ -18410,12 +18604,12 @@ var MultiSchemaField_default = AnyOfField;
 
 // node_modules/.pnpm/@rjsf+core@5.24.13_@rjsf+utils@5.24.13_react@16.14.0__react@16.14.0/node_modules/@rjsf/core/lib/components/fields/NumberField.js
 import { jsx as _jsx5 } from "react/jsx-runtime.js";
-import { useState as useState2, useCallback } from "react";
+import { useState as useState3, useCallback } from "react";
 var trailingCharMatcherWithPrefix = /\.([0-9]*0)*$/;
 var trailingCharMatcher = /[0.]0*$/;
 function NumberField(props) {
   const { registry, onChange, formData, value: initialValue } = props;
-  const [lastValue, setLastValue] = useState2(initialValue);
+  const [lastValue, setLastValue] = useState3(initialValue);
   const { StringField: StringField2 } = registry.fields;
   let value = formData;
   const handleChange = useCallback((value2, errorSchema, id) => {
@@ -19244,10 +19438,10 @@ function StringField(props) {
 var StringField_default = StringField;
 
 // node_modules/.pnpm/@rjsf+core@5.24.13_@rjsf+utils@5.24.13_react@16.14.0__react@16.14.0/node_modules/@rjsf/core/lib/components/fields/NullField.js
-import { useEffect as useEffect2 } from "react";
+import { useEffect as useEffect3 } from "react";
 function NullField(props) {
   const { formData, onChange } = props;
-  useEffect2(() => {
+  useEffect3(() => {
     if (formData === void 0) {
       onChange(null);
     }
@@ -19588,7 +19782,7 @@ var templates_default = templates;
 
 // node_modules/.pnpm/@rjsf+core@5.24.13_@rjsf+utils@5.24.13_react@16.14.0__react@16.14.0/node_modules/@rjsf/core/lib/components/widgets/AltDateWidget.js
 import { jsx as _jsx27, jsxs as _jsxs14 } from "react/jsx-runtime.js";
-import { useCallback as useCallback4, useEffect as useEffect3, useReducer, useState as useState3 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect4, useReducer, useState as useState4 } from "react";
 function readyForChange(state) {
   return Object.values(state).every((value) => value !== -1);
 }
@@ -19599,11 +19793,11 @@ function DateElement({ type, range, value, select, rootId, name, disabled, reado
 }
 function AltDateWidget({ time = false, disabled = false, readonly = false, autofocus = false, options, id, name, registry, onBlur, onFocus, onChange, value }) {
   const { translateString } = registry;
-  const [lastValue, setLastValue] = useState3(value);
+  const [lastValue, setLastValue] = useState4(value);
   const [state, setState] = useReducer((state2, action) => {
     return { ...state2, ...action };
   }, parseDateString(value, time));
-  useEffect3(() => {
+  useEffect4(() => {
     const stateValue = toDateString(state, time);
     if (readyForChange(state) && stateValue !== value) {
       onChange(stateValue);
@@ -19764,7 +19958,7 @@ function FileInfoPreview({ fileInfo, registry }) {
   }
   return _jsxs17(_Fragment3, { children: [" ", _jsx35("a", { download: `preview-${name}`, href: dataURL, className: "file-download", children: translateString(TranslatableString.PreviewLabel) })] });
 }
-function FilesInfo({ filesInfo, registry, preview, onRemove, options }) {
+function FilesInfo({ filesInfo, registry, preview: preview2, onRemove, options }) {
   if (filesInfo.length === 0) {
     return null;
   }
@@ -19773,7 +19967,7 @@ function FilesInfo({ filesInfo, registry, preview, onRemove, options }) {
   return _jsx35("ul", { className: "file-info", children: filesInfo.map((fileInfo, key) => {
     const { name, size, type } = fileInfo;
     const handleRemove = () => onRemove(key);
-    return _jsxs17("li", { children: [_jsx35(index_modern_default, { children: translateString(TranslatableString.FilesInfo, [name, type, String(size)]) }), preview && _jsx35(FileInfoPreview, { fileInfo, registry }), _jsx35(RemoveButton2, { onClick: handleRemove, registry })] }, key);
+    return _jsxs17("li", { children: [_jsx35(index_modern_default, { children: translateString(TranslatableString.FilesInfo, [name, type, String(size)]) }), preview2 && _jsx35(FileInfoPreview, { fileInfo, registry }), _jsx35(RemoveButton2, { onClick: handleRemove, registry })] }, key);
   }) });
 }
 function extractFileInfo(dataURLs) {
@@ -21108,14 +21302,182 @@ function fieldErrors(issues) {
   return root2;
 }
 
+// dist/rjsf-templates.js
+import * as React3 from "react";
+var ItemNumber = React3.createContext(1);
+var PropertyKey = React3.createContext(void 0);
+function valueFieldTemplate(DefaultTemplate, flag) {
+  return function ValueField2(props) {
+    if (!(flag in props.schema))
+      return React3.createElement(DefaultTemplate, { ...props });
+    return React3.createElement(
+      PropertyKey.Provider,
+      { value: props.label },
+      React3.createElement(DefaultTemplate, { ...props, label: "\u5024" })
+    );
+  };
+}
+function numberedObjectTemplate(DefaultTemplate, flag) {
+  return function ObjectItems2(props) {
+    let number = 0;
+    const properties = props.properties.map((property2) => {
+      var _a;
+      const schema4 = (_a = props.schema.properties) === null || _a === void 0 ? void 0 : _a[property2.name];
+      if (!schema4 || typeof schema4 !== "object" || !(flag in schema4) || property2.hidden)
+        return property2;
+      return { ...property2, content: React3.createElement(ItemNumber.Provider, { key: property2.name, value: ++number }, property2.content) };
+    });
+    return React3.createElement(DefaultTemplate, { ...props, properties });
+  };
+}
+function additionalItemTemplate(flag) {
+  return function AdditionalItem2(props) {
+    const number = React3.useContext(ItemNumber);
+    const propertyKey = React3.useContext(PropertyKey);
+    const { id, classNames, style, children, schema: schema4, label, disabled, readonly, onKeyChange, onDropPropertyClick } = props;
+    if (!(flag in schema4))
+      return React3.createElement("div", { className: classNames, style }, children);
+    const key = propertyKey !== null && propertyKey !== void 0 ? propertyKey : label;
+    return React3.createElement(
+      "div",
+      { className: classNames, style, "data-block-editor-item": "" },
+      React3.createElement(
+        "div",
+        { "data-block-editor-item-heading": "" },
+        React3.createElement(
+          "span",
+          null,
+          "\u30FB\u9805\u76EE",
+          number
+        ),
+        React3.createElement(ItemMenu, { disabled: disabled || readonly, onClick: onDropPropertyClick(key) })
+      ),
+      React3.createElement(
+        "div",
+        { "data-block-editor-pair-row": "" },
+        React3.createElement("label", { htmlFor: `${id}-key` }, "\u30AD\u30FC"),
+        React3.createElement("input", { id: `${id}-key`, type: "text", defaultValue: key, disabled, readOnly: readonly, onBlur: (event) => onKeyChange(event.target.value) })
+      ),
+      React3.createElement("div", { "data-block-editor-pair-row": "" }, children)
+    );
+  };
+}
+function ItemMenu({ disabled, onClick }) {
+  const [open, setOpen] = React3.useState(false);
+  const container = React3.useRef(null);
+  const trigger = React3.useRef(null);
+  const item = React3.useRef(null);
+  React3.useEffect(() => {
+    var _a;
+    if (!open)
+      return;
+    (_a = item.current) === null || _a === void 0 ? void 0 : _a.focus();
+    const closeOutside = (event) => {
+      var _a2;
+      if (!((_a2 = container.current) === null || _a2 === void 0 ? void 0 : _a2.contains(event.target)))
+        setOpen(false);
+    };
+    const keepEscapeInMenu = (event) => {
+      var _a2;
+      if (event.key !== "Escape" || event.isComposing || event.keyCode === 229)
+        return;
+      event.preventDefault();
+      event.stopPropagation();
+      setOpen(false);
+      (_a2 = trigger.current) === null || _a2 === void 0 ? void 0 : _a2.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]);
+  React3.useEffect(() => {
+    if (disabled)
+      setOpen(false);
+  }, [disabled]);
+  return React3.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);
+      }
+    } },
+    React3.createElement("button", { "aria-label": "\u9805\u76EE\u306E\u30E1\u30CB\u30E5\u30FC", "aria-haspopup": "menu", "aria-expanded": open && !disabled, disabled, ref: trigger, type: "button", onClick: () => setOpen(!open) }, "\u2026"),
+    open && !disabled ? React3.createElement(
+      "div",
+      { role: "menu", "aria-label": "\u9805\u76EE\u306E\u64CD\u4F5C" },
+      React3.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);
+      } }, "\u{1F5D1}\uFE0F\u3053\u306E\u9805\u76EE\u3092\u524A\u9664")
+    ) : null
+  );
+}
+function AddItemButton({ disabled, onClick, className }) {
+  return React3.createElement("button", { className, "data-block-editor-add-item": "", disabled, type: "button", onClick }, "\u2795\u9805\u76EE\u3092\u8FFD\u52A0");
+}
+function ArrayItem(props) {
+  const { children, className, disabled, readonly, index, hasMoveUp, hasMoveDown, hasCopy, hasRemove, onReorderClick, onCopyIndexClick, onDropIndexClick } = props;
+  const locked = disabled || readonly;
+  return React3.createElement(
+    "div",
+    { className, "data-block-editor-item": "" },
+    React3.createElement(
+      "div",
+      { "data-block-editor-item-heading": "" },
+      React3.createElement(
+        "span",
+        null,
+        "\u30FB\u9805\u76EE",
+        index + 1
+      ),
+      React3.createElement(
+        "div",
+        { "data-block-editor-item-actions": "" },
+        hasMoveUp || hasMoveDown ? React3.createElement(
+          React3.Fragment,
+          null,
+          React3.createElement("button", { "aria-label": "\u9805\u76EE\u3092\u4E0A\u3078\u79FB\u52D5", disabled: locked || !hasMoveUp, type: "button", onClick: onReorderClick(index, index - 1) }, "\u2191"),
+          React3.createElement("button", { "aria-label": "\u9805\u76EE\u3092\u4E0B\u3078\u79FB\u52D5", disabled: locked || !hasMoveDown, type: "button", onClick: onReorderClick(index, index + 1) }, "\u2193")
+        ) : null,
+        hasCopy ? React3.createElement("button", { disabled: locked, type: "button", onClick: onCopyIndexClick(index) }, "\u9805\u76EE\u3092\u8907\u88FD") : null,
+        hasRemove ? React3.createElement(ItemMenu, { disabled: locked, onClick: onDropIndexClick(index) }) : null
+      )
+    ),
+    children
+  );
+}
+
 // dist/rjsf.js
 function moduleExports4(namespace) {
   const fallback = namespace.default;
   return fallback && typeof fallback === "object" && "__esModule" in fallback ? fallback : namespace;
 }
 var Form2 = moduleExports4(lib_exports2).default;
-var { getDefaultFormState: getDefaultFormState2 } = moduleExports4(lib_exports);
+var { getDefaultFormState: getDefaultFormState2, ADDITIONAL_PROPERTY_FLAG: ADDITIONAL_PROPERTY_FLAG2 } = moduleExports4(lib_exports);
 var { customizeValidator: customizeValidator2 } = moduleExports4(lib_exports3);
+var defaultTemplates = moduleExports4(lib_exports2).getDefaultRegistry().templates;
+var ObjectItems = numberedObjectTemplate(defaultTemplates.ObjectFieldTemplate, ADDITIONAL_PROPERTY_FLAG2);
+var AdditionalItem = additionalItemTemplate(ADDITIONAL_PROPERTY_FLAG2);
+var ValueField = valueFieldTemplate(defaultTemplates.FieldTemplate, ADDITIONAL_PROPERTY_FLAG2);
 var nextViewId = 0;
 function createSchemaBundleEditor(options) {
   const { schemaBundle, validationContext: provider, ownerValidate, apiVersion, extensionId, editorId, opcodes, argument, format, uiSchema, validateData } = options;
@@ -21164,14 +21526,34 @@ function createSchemaBundleEditor(options) {
     ...validateData === void 0 ? {} : { validateData }
   }, { issuesFor, dialect: result.validator.dialect });
 }
-function createBlockEditorService() {
+function createBlockEditorService(options) {
+  if ((options === null || options === void 0 ? void 0 : options.fixedInputs) !== void 0 && 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 = /* @__PURE__ */ 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;
@@ -21284,7 +21666,7 @@ function createSchemaEditorImpl(options, bundle) {
       if (context.getState().issues.length === 0) {
         context.setValidationIssues(issuesFor(dataFor(context.getDraft())));
       }
-      const render3 = () => {
+      const render4 = () => {
         if (!active)
           return;
         const state = context.getState();
@@ -21293,6 +21675,13 @@ function createSchemaEditorImpl(options, bundle) {
           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: {
@@ -21313,7 +21702,7 @@ function createSchemaEditorImpl(options, bundle) {
             context.setValidationIssues(issuesFor(data));
           }
         };
-        ReactDOM2.render(React2.createElement(Form2, props, React2.createElement("span", { hidden: true })), container);
+        ReactDOM3.render(React4.createElement(Form2, props, React4.createElement("span", { hidden: true })), container);
       };
       const schedule = () => {
         if (scheduled || !active)
@@ -21322,28 +21711,29 @@ function createSchemaEditorImpl(options, bundle) {
         void Promise.resolve().then(() => {
           scheduled = false;
           if (active)
-            render3();
+            render4();
         });
       };
       unsubscribe = context.subscribe(schedule);
       try {
-        render3();
+        render4();
       } catch (error) {
         active = false;
         unsubscribe();
-        ReactDOM2.unmountComponentAtNode(container);
+        ReactDOM3.unmountComponentAtNode(container);
         throw error;
       }
       return () => {
         active = false;
         unsubscribe();
-        ReactDOM2.unmountComponentAtNode(container);
+        ReactDOM3.unmountComponentAtNode(container);
       };
     }
   };
 }
 export {
   createBlockEditorService,
+  createFixedInputEditor,
   createSchemaBundleEditor,
   createSchemaEditor,
   createSourceEditor