@sepveneto/dnde-core 0.6.3 → 0.6.5

package/dist/index.cjs

@@ -1,10 +1,12 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -32,22 +34,700 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  Container: () => Container,
   EventEmitter: () => EventEmitter,
+  Node: () => Node,
+  Widget: () => Widget,
+  createCapabilityCatalog: () => createCapabilityCatalog,
   createCopy: () => createCopy,
   createDelete: () => createDelete,
   editorContextKey: () => editorContextKey,
+  findCustomCapability: () => findCustomCapability,
+  findFieldCapability: () => findFieldCapability,
+  findWidgetCapability: () => findWidgetCapability,
   isBox: () => isBox,
+  isKnownScope: () => isKnownScope,
+  isStyleField: () => isStyleField,
+  listStaticOptions: () => listStaticOptions,
   schema: () => schema,
+  validateEditorDsl: () => validateEditorDsl,
   widget: () => widget,
   widgetType: () => widgetType
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/class/Widget.ts
+var import_async_validator = __toESM(require("async-validator"), 1);
+var Widget = class _Widget {
+  constructor(widget2) {
+    this._data = JSON.parse(JSON.stringify(widget2));
+    if (widget2.agent)
+      this._data.agent = __spreadValues({}, widget2.agent);
+    this.name = widget2._name;
+    this.view = widget2._view;
+    this.container = widget2.container;
+  }
+  clone() {
+    return new _Widget(this._data);
+  }
+  get icon() {
+    return this._data._icon;
+  }
+  get props() {
+    var _a;
+    return ((_a = this._data.schema) == null ? void 0 : _a.props) || [];
+  }
+  get style() {
+    var _a;
+    return ((_a = this._data.schema) == null ? void 0 : _a.style) || [];
+  }
+  get defaultStyle() {
+    return this._data.style;
+  }
+  get defaultData() {
+    return this._data.data;
+  }
+  get agent() {
+    return this._data.agent;
+  }
+  get draggable() {
+    var _a, _b;
+    return (_b = (_a = this._data.meta) == null ? void 0 : _a.draggable) != null ? _b : true;
+  }
+  get isFixed() {
+    var _a;
+    const fixed = (_a = this._data.meta) == null ? void 0 : _a.fixed;
+    if (fixed === true) {
+      return "header";
+    } else {
+      return fixed;
+    }
+  }
+  get visible() {
+    var _a, _b;
+    return (_b = (_a = this._data.meta) == null ? void 0 : _a.visible) != null ? _b : true;
+  }
+  get validatorProps() {
+    var _a, _b;
+    const _rules = ((_b = (_a = this._data.schema) == null ? void 0 : _a.props) == null ? void 0 : _b.reduce((all, curr) => {
+      all[curr.key] = curr.rules || [];
+      return all;
+    }, {})) || {};
+    const validator = new import_async_validator.default(_rules);
+    return validator;
+  }
+  get validatorStyle() {
+    var _a, _b;
+    const _rules = ((_b = (_a = this._data.schema) == null ? void 0 : _a.style) == null ? void 0 : _b.reduce((all, curr) => {
+      all[curr.key] = curr.rules || [];
+      return all;
+    }, {})) || {};
+    const validator = new import_async_validator.default(_rules);
+    return validator;
+  }
+};
+
+// src/class/Container.ts
+var Container = class extends Widget {
+  constructor(data) {
+    super(data);
+    this.view = "container";
+  }
+};
+
+// src/class/Node.ts
+var import_uuid = require("uuid");
+var Node = class _Node {
+  constructor(widget2, info) {
+    this.level = 0;
+    this.list = [];
+    this.data = {};
+    this.style = {};
+    this.hovering = false;
+    this.dragging = false;
+    this.widget = widget2;
+    this.wid = (info == null ? void 0 : info.uuid) || (0, import_uuid.v4)();
+    this.list = (info == null ? void 0 : info.list) || [];
+    this.data = (info == null ? void 0 : info.props) || {};
+    this.style = (info == null ? void 0 : info.style) || {};
+  }
+  get info() {
+    return __spreadValues({
+      style: this.style
+    }, this.data);
+  }
+  get isContainer() {
+    return !!this.widget.container;
+  }
+  get hasList() {
+    return this.list && this.list.length > 0;
+  }
+  get mouseover() {
+    return this.hovering;
+  }
+  get type() {
+    var _a;
+    return ((_a = this.widget) == null ? void 0 : _a.view) || "root";
+  }
+  get name() {
+    var _a;
+    return ((_a = this.widget) == null ? void 0 : _a.name) || "\u9875\u9762";
+  }
+  get visible() {
+    if ("isShow" in this.data)
+      return Boolean(this.data.isShow);
+  }
+  validate(only = false) {
+    return __async(this, null, function* () {
+      const valid = yield Promise.all([
+        this.widget.validatorProps.validate(this.data),
+        this.widget.validatorStyle.validate(this.style)
+      ]).catch(() => {
+        return false;
+      });
+      if (!valid) {
+        return this.wid;
+      }
+      if (only || !this.list) {
+        return;
+      }
+      for (const item of this.list) {
+        const invalid = yield item.validate();
+        if (invalid) {
+          return invalid;
+        }
+      }
+    });
+  }
+  triggerHover(hover) {
+    this.hovering = hover;
+  }
+  setList(list) {
+    this.list = list;
+  }
+  copy() {
+    var _a;
+    const list = (_a = this.list) == null ? void 0 : _a.map((item) => item.copy());
+    const info = {
+      props: JSON.parse(JSON.stringify(this.data)),
+      style: JSON.parse(JSON.stringify(this.style)),
+      list
+    };
+    return new _Node(this.widget.clone(), info);
+  }
+  parse() {
+    var _a;
+    const res = {
+      _uuid: this.wid,
+      _name: this.name,
+      _view: this.type,
+      data: this.data,
+      style: this.style,
+      list: (_a = this.list) == null ? void 0 : _a.map((item) => item.parse())
+    };
+    return res;
+  }
+};
+
+// src/capability.ts
+function optionValues(item) {
+  if (!("options" in item) || !Array.isArray(item.options))
+    return;
+  return item.options.map((option) => option && typeof option === "object" ? option.value : void 0).filter((value) => value !== void 0);
+}
+function fieldFromSchema(item, scope) {
+  var _a, _b, _c;
+  if (item.type === "custom")
+    return;
+  let valueType = "unknown";
+  let enumValues;
+  let minimum;
+  let maximum;
+  switch (item.type) {
+    case "input":
+    case "colorPicker":
+    case "datetimePicker":
+      valueType = "string";
+      break;
+    case "number":
+    case "styleNumber":
+      valueType = "number";
+      minimum = typeof ((_a = item.attrs) == null ? void 0 : _a.min) === "number" ? item.attrs.min : void 0;
+      maximum = typeof ((_b = item.attrs) == null ? void 0 : _b.max) === "number" ? item.attrs.max : void 0;
+      break;
+    case "switch":
+      if ("attrs" in item && item.attrs && ("activeValue" in item.attrs || "inactiveValue" in item.attrs)) {
+        valueType = "enum";
+        enumValues = [
+          item.attrs.activeValue,
+          item.attrs.inactiveValue
+        ].filter((value) => value !== void 0);
+      } else {
+        valueType = "boolean";
+      }
+      break;
+    case "checkbox":
+      valueType = "boolean";
+      break;
+    case "select":
+    case "radio":
+    case "radioButton":
+      valueType = "enum";
+      enumValues = optionValues(item);
+      break;
+  }
+  const rules = Array.isArray(item.rules) ? item.rules : item.rules ? [item.rules] : [];
+  return {
+    source: "prop",
+    key: item.key,
+    label: item.label,
+    valueType,
+    scope: (_c = item.scope) != null ? _c : scope,
+    required: rules.some((rule) => rule.required === true),
+    readOnly: item.readOnly === true,
+    enum: enumValues,
+    minimum,
+    maximum
+  };
+}
+function registeredCustomTypes(registration) {
+  var _a;
+  return ((_a = registration == null ? void 0 : registration.customTypes) != null ? _a : []).map((type) => ({
+    type: type.type,
+    capabilities: type.capabilities.map((capability) => __spreadValues({}, capability))
+  }));
+}
+function schemaCustomTypes(widget2) {
+  var _a, _b;
+  return ((_b = (_a = widget2.schema) == null ? void 0 : _a.props) != null ? _b : []).filter((item) => item.type === "custom").map((item) => item.name);
+}
+function createCapabilityCatalog(widgets, registry = {}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  const catalog = {
+    catalogVersion: "1.0",
+    widgets: []
+  };
+  for (const widget2 of widgets) {
+    const registration = registry[widget2._view];
+    const declared = registeredCustomTypes(registration);
+    const declaredMap = new Map(declared.map((type) => [type.type, type]));
+    const customTypes = schemaCustomTypes(widget2).map((type) => {
+      var _a2;
+      return (_a2 = declaredMap.get(type)) != null ? _a2 : { type, capabilities: [] };
+    });
+    catalog.widgets.push({
+      type: widget2._view,
+      name: widget2._name,
+      description: (_e = (_d = (_a = widget2.agent) == null ? void 0 : _a.description) != null ? _d : (_c = (_b = widget2.agent) == null ? void 0 : _b.layout) == null ? void 0 : _c.description) != null ? _e : "",
+      defaultData: JSON.parse(JSON.stringify((_f = widget2.data) != null ? _f : {})),
+      defaultStyle: JSON.parse(JSON.stringify((_g = widget2.style) != null ? _g : {})),
+      fields: [
+        ...((_i = (_h = widget2.schema) == null ? void 0 : _h.props) != null ? _i : []).map((item) => fieldFromSchema(item, "content")).filter((item) => Boolean(item)),
+        ...((_k = (_j = widget2.schema) == null ? void 0 : _j.style) != null ? _k : []).map((item) => fieldFromSchema(item, "style")).filter((item) => Boolean(item))
+      ],
+      customTypes,
+      staticOptions: ((_l = registration == null ? void 0 : registration.staticOptions) != null ? _l : []).map((option) => __spreadProps(__spreadValues({}, option), {
+        aliases: [...option.aliases],
+        types: [...option.types]
+      }))
+    });
+  }
+  return catalog;
+}
+function findWidgetCapability(catalog, type) {
+  return catalog.widgets.find((widget2) => widget2.type === type);
+}
+function findFieldCapability(widget2, key) {
+  return widget2.fields.find((field) => field.key === key);
+}
+function findCustomCapability(widget2, type, name) {
+  var _a;
+  return (_a = widget2.customTypes.find((item) => item.type === type)) == null ? void 0 : _a.capabilities.find((capability) => capability.name === name);
+}
+function listStaticOptions(catalog, widgetTypes, types) {
+  const selected = (widgetTypes == null ? void 0 : widgetTypes.length) ? catalog.widgets.filter((widget2) => widgetTypes.includes(widget2.type)) : catalog.widgets;
+  return selected.flatMap((widget2) => widget2.staticOptions).filter((option) => !(types == null ? void 0 : types.length) || option.types.some((type) => types.includes(type)));
+}
+
+// src/dsl.ts
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function isScope(value) {
+  return value === "style" || value === "content" || value === "layout";
+}
+function allowsScope(mode, scope) {
+  if (mode === "any")
+    return true;
+  return mode === "style_only" && scope === "style" || mode === "content_only" && scope === "content" || mode === "layout_only" && scope === "layout";
+}
+function matchesValueType(field, value) {
+  var _a, _b;
+  if (!field)
+    return false;
+  switch (field.valueType) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "integer":
+      return Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "enum":
+      return (_b = (_a = field.enum) == null ? void 0 : _a.some((item) => Object.is(item, value))) != null ? _b : true;
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+    default:
+      return true;
+  }
+}
+function validateFieldValue(widget2, key, value, scopeMode, path, issues) {
+  const field = findFieldCapability(widget2, key);
+  if (!field) {
+    issues.push({
+      code: "unknown_prop",
+      path,
+      message: `${widget2.type} \u6CA1\u6709\u767B\u8BB0\u6807\u51C6\u5B57\u6BB5 ${key}`
+    });
+    return false;
+  }
+  if (field.readOnly) {
+    issues.push({
+      code: "read_only_prop",
+      path,
+      message: `${widget2.type}.${key} \u4E3A\u53EA\u8BFB\u5B57\u6BB5`
+    });
+    return false;
+  }
+  if (!allowsScope(scopeMode, field.scope)) {
+    issues.push({
+      code: "scope_violation",
+      path,
+      message: `${widget2.type}.${key} \u5C5E\u4E8E ${field.scope}\uFF0C\u5F53\u524D scope \u4E0D\u5141\u8BB8\u5199\u5165`
+    });
+    return false;
+  }
+  if (!matchesValueType(field, value)) {
+    issues.push({
+      code: "invalid_prop_type",
+      path,
+      message: `${widget2.type}.${key} \u9700\u8981 ${field.valueType} \u7C7B\u578B`
+    });
+    return false;
+  }
+  if (typeof value === "number" && field.minimum !== void 0 && value < field.minimum) {
+    issues.push({
+      code: "prop_below_minimum",
+      path,
+      message: `${widget2.type}.${key} \u4E0D\u80FD\u5C0F\u4E8E ${field.minimum}`
+    });
+    return false;
+  }
+  if (typeof value === "number" && field.maximum !== void 0 && value > field.maximum) {
+    issues.push({
+      code: "prop_above_maximum",
+      path,
+      message: `${widget2.type}.${key} \u4E0D\u80FD\u5927\u4E8E ${field.maximum}`
+    });
+    return false;
+  }
+  return true;
+}
+function validateProps(widget2, props, container, scopeMode, path, issues) {
+  if (props === void 0)
+    return;
+  if (!props || typeof props !== "object" || Array.isArray(props)) {
+    issues.push({
+      code: "invalid_props",
+      path,
+      message: "props \u5FC5\u987B\u662F\u5BF9\u8C61"
+    });
+    return;
+  }
+  Object.entries(props).forEach(([key, value]) => {
+    const field = findFieldCapability(widget2, key);
+    if (field && container === "props" && field.scope === "style") {
+      issues.push({
+        code: "style_field_in_props",
+        path: `${path}.${key}`,
+        message: `${widget2.type}.${key} \u662F\u6837\u5F0F\u5B57\u6BB5\uFF0C\u5FC5\u987B\u5199\u5165 style`
+      });
+      return;
+    }
+    if (field && container === "style" && field.scope !== "style") {
+      issues.push({
+        code: "non_style_field_in_style",
+        path: `${path}.${key}`,
+        message: `${widget2.type}.${key} \u4E0D\u662F\u6837\u5F0F\u5B57\u6BB5\uFF0C\u4E0D\u80FD\u5199\u5165 style`
+      });
+      return;
+    }
+    validateFieldValue(widget2, key, value, scopeMode, `${path}.${key}`, issues);
+  });
+}
+function validateCustom(widget2, custom, scopeMode, path, issues) {
+  if (custom === void 0)
+    return;
+  if (!Array.isArray(custom)) {
+    issues.push({
+      code: "invalid_custom_operations",
+      path,
+      message: "custom \u5FC5\u987B\u662F\u80FD\u529B\u64CD\u4F5C\u6570\u7EC4"
+    });
+    return;
+  }
+  custom.forEach((rawOperation, index) => {
+    const operation = asRecord(rawOperation);
+    const type = typeof operation.type === "string" ? operation.type : "";
+    const name = typeof operation.capability === "string" ? operation.capability : "";
+    const capability = findCustomCapability(widget2, type, name);
+    if (!capability) {
+      issues.push({
+        code: "unsupported_capability",
+        path: `${path}[${index}]`,
+        message: `${widget2.type} \u672A\u767B\u8BB0 custom type ${type} \u7684\u80FD\u529B ${name}`
+      });
+      return;
+    }
+    if (!allowsScope(scopeMode, capability.writableScope)) {
+      issues.push({
+        code: "scope_violation",
+        path: `${path}[${index}]`,
+        message: `\u80FD\u529B ${name} \u5C5E\u4E8E ${capability.writableScope}\uFF0C\u5F53\u524D scope \u4E0D\u5141\u8BB8\u5199\u5165`
+      });
+    }
+  });
+}
+function placementCount(placement) {
+  return ["afterUuid", "beforeUuid", "afterKey", "beforeKey"].filter((key) => typeof placement[key] === "string" && placement[key]).length;
+}
+function validateEditorDsl(input, options) {
+  const issues = [];
+  const dsl = asRecord(input);
+  const operations = Array.isArray(dsl.operations) ? dsl.operations : [];
+  const scope = asRecord(dsl.scope);
+  const scopeMode = scope.mode;
+  if (dsl.dslVersion !== "1.1") {
+    issues.push({
+      code: "unsupported_dsl_version",
+      path: "dslVersion",
+      message: "\u4EC5\u652F\u6301 dslVersion 1.1"
+    });
+  }
+  if (dsl.baseRevision !== options.snapshot.revision) {
+    issues.push({
+      code: "stale_revision",
+      path: "baseRevision",
+      message: `DSL \u57FA\u4E8E revision ${String(dsl.baseRevision)}\uFF0C\u5F53\u524D\u4E3A ${options.snapshot.revision}`
+    });
+  }
+  if (scopeMode !== "style_only" && scopeMode !== "content_only" && scopeMode !== "layout_only" && scopeMode !== "any") {
+    issues.push({
+      code: "invalid_scope",
+      path: "scope.mode",
+      message: "scope.mode \u5FC5\u987B\u662F style_only/content_only/layout_only/any"
+    });
+  }
+  const scopeTargets = Array.isArray(scope.targets) ? scope.targets.filter((target) => typeof target === "string") : [];
+  if (!operations.length) {
+    issues.push({
+      code: "empty_operations",
+      path: "operations",
+      message: "DSL \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u64CD\u4F5C"
+    });
+  }
+  const nodeUuids = new Set(options.snapshot.nodes.map((node) => node.uuid));
+  const addKeys = /* @__PURE__ */ new Set();
+  const normalizedOperations = [];
+  operations.forEach((rawOperation, index) => {
+    var _a, _b;
+    const operation = asRecord(rawOperation);
+    const path = `operations[${index}]`;
+    const op = operation.op;
+    if (op !== "add" && op !== "update" && op !== "delete") {
+      issues.push({
+        code: "unsupported_operation",
+        path: `${path}.op`,
+        message: `\u4E0D\u652F\u6301\u7684\u64CD\u4F5C ${String(op)}`
+      });
+      return;
+    }
+    if (op === "add") {
+      const key = typeof operation.key === "string" ? operation.key : "";
+      const widgetType2 = typeof operation.widget === "string" ? operation.widget : "";
+      const widget3 = findWidgetCapability(options.catalog, widgetType2);
+      if (!key) {
+        issues.push({ code: "missing_key", path: `${path}.key`, message: "add \u5FC5\u987B\u63D0\u4F9B\u6279\u5185\u552F\u4E00 key" });
+      } else if (addKeys.has(key)) {
+        issues.push({ code: "duplicate_key", path: `${path}.key`, message: `\u6279\u5185 key \u91CD\u590D\uFF1A${key}` });
+      }
+      if (!widget3) {
+        issues.push({
+          code: "unknown_widget",
+          path: `${path}.widget`,
+          message: `\u7EC4\u4EF6\u80FD\u529B\u76EE\u5F55\u4E2D\u4E0D\u5B58\u5728 ${widgetType2}`
+        });
+      }
+      const placement = asRecord(operation.placement);
+      if (placementCount(placement) > 1) {
+        issues.push({
+          code: "ambiguous_placement",
+          path: `${path}.placement`,
+          message: "placement \u53EA\u80FD\u6307\u5B9A\u4E00\u4E2A\u76F8\u5BF9\u4F4D\u7F6E"
+        });
+      }
+      for (const keyName of ["afterKey", "beforeKey"]) {
+        const reference = typeof placement[keyName] === "string" ? placement[keyName] : "";
+        if (reference && !addKeys.has(reference)) {
+          issues.push({
+            code: "unknown_batch_key",
+            path: `${path}.placement.${keyName}`,
+            message: `\u6279\u5185 key ${reference} \u5C1A\u672A\u521B\u5EFA`
+          });
+        }
+      }
+      for (const uuidName of ["afterUuid", "beforeUuid"]) {
+        const reference = typeof placement[uuidName] === "string" ? placement[uuidName] : "";
+        if (reference && !nodeUuids.has(reference)) {
+          issues.push({
+            code: "unknown_node",
+            path: `${path}.placement.${uuidName}`,
+            message: `\u8282\u70B9 ${reference} \u4E0D\u5B58\u5728`
+          });
+        }
+      }
+      if (widget3) {
+        const customOperations = operation.custom === void 0 ? [] : operation.custom;
+        validateProps(widget3, operation.props, "props", scopeMode, `${path}.props`, issues);
+        validateProps(widget3, operation.style, "style", scopeMode, `${path}.style`, issues);
+        validateCustom(widget3, customOperations, scopeMode, `${path}.custom`, issues);
+      }
+      if (key)
+        addKeys.add(key);
+      normalizedOperations.push({
+        op,
+        key,
+        widget: widgetType2,
+        placement,
+        props: asRecord(operation.props),
+        style: asRecord(operation.style),
+        custom: Array.isArray(operation.custom) ? operation.custom : []
+      });
+      return;
+    }
+    const uuid = typeof operation.uuid === "string" ? operation.uuid : "";
+    const node = options.snapshot.nodes.find((item) => item.uuid === uuid);
+    if (!node) {
+      issues.push({
+        code: "unknown_node",
+        path: `${path}.uuid`,
+        message: `\u8282\u70B9 ${uuid || "(\u7A7A)"} \u4E0D\u5B58\u5728`
+      });
+    }
+    if (scopeTargets.length && !scopeTargets.includes(uuid)) {
+      issues.push({
+        code: "target_outside_scope",
+        path: `${path}.uuid`,
+        message: `\u8282\u70B9 ${uuid} \u4E0D\u5728 scope.targets \u5185`
+      });
+    }
+    if (op === "delete") {
+      if (!operation.confirmToken) {
+        issues.push({
+          code: "delete_confirmation_required",
+          path: `${path}.confirmToken`,
+          message: "\u5220\u9664\u64CD\u4F5C\u5FC5\u987B\u643A\u5E26\u4E00\u6B21\u6027\u786E\u8BA4\u4EE4\u724C"
+        });
+      } else if (!((_a = options.snapshot.confirmTokens) == null ? void 0 : _a.includes(String(operation.confirmToken)))) {
+        issues.push({
+          code: "invalid_confirm_token",
+          path: `${path}.confirmToken`,
+          message: "\u5220\u9664\u786E\u8BA4\u4EE4\u724C\u65E0\u6548\u6216\u5DF2\u8FC7\u671F"
+        });
+      }
+      normalizedOperations.push({ op, uuid, confirmToken: String((_b = operation.confirmToken) != null ? _b : "") });
+      return;
+    }
+    const widget2 = node ? findWidgetCapability(options.catalog, node.type) : void 0;
+    if (node && widget2) {
+      validateProps(widget2, operation.props, "props", scopeMode, `${path}.props`, issues);
+      validateProps(widget2, operation.style, "style", scopeMode, `${path}.style`, issues);
+      validateCustom(widget2, operation.custom, scopeMode, `${path}.custom`, issues);
+    }
+    normalizedOperations.push({
+      op,
+      uuid,
+      props: asRecord(operation.props),
+      style: asRecord(operation.style),
+      custom: Array.isArray(operation.custom) ? operation.custom : []
+    });
+  });
+  if (scopeTargets.some((target) => !nodeUuids.has(target))) {
+    issues.push({
+      code: "unknown_scope_target",
+      path: "scope.targets",
+      message: "scope.targets \u5305\u542B\u4E0D\u5B58\u5728\u7684\u8282\u70B9"
+    });
+  }
+  return __spreadValues({
+    ok: issues.length === 0,
+    issues
+  }, issues.length ? {} : {
+    normalized: {
+      dslVersion: "1.1",
+      baseRevision: options.snapshot.revision,
+      scope: {
+        mode: scopeMode,
+        targets: scopeTargets
+      },
+      operations: normalizedOperations
+    }
+  });
+}
+function isStyleField(widget2, key) {
+  var _a;
+  return ((_a = findFieldCapability(widget2, key)) == null ? void 0 : _a.scope) === "style";
+}
+function isKnownScope(value) {
+  return isScope(value);
+}
+
 // src/helper/EventEmitter.ts
 var EventEmitter = class {
   constructor(subscribeFn) {
@@ -93,6 +773,8 @@ var schema = {
       _role: config._role,
       label: config.label,
       key: config.key,
+      scope: config.scope,
+      readOnly: config.readOnly,
       type,
       formItem: config.formItem,
       rules: normalizeRules(config),
@@ -259,12 +941,23 @@ function isBox(schema2) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Container,
   EventEmitter,
+  Node,
+  Widget,
+  createCapabilityCatalog,
   createCopy,
   createDelete,
   editorContextKey,
+  findCustomCapability,
+  findFieldCapability,
+  findWidgetCapability,
   isBox,
+  isKnownScope,
+  isStyleField,
+  listStaticOptions,
   schema,
+  validateEditorDsl,
   widget,
   widgetType
 });