@sepveneto/dnde-core 0.6.3 → 0.6.5

package/dist/dsl.cjs

@@ -0,0 +1,405 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+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;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dsl.ts
+var dsl_exports = {};
+__export(dsl_exports, {
+  isKnownScope: () => isKnownScope,
+  isStyleField: () => isStyleField,
+  validateEditorDsl: () => validateEditorDsl
+});
+module.exports = __toCommonJS(dsl_exports);
+
+// src/capability.ts
+function findWidgetCapability(catalog, type) {
+  return catalog.widgets.find((widget) => widget.type === type);
+}
+function findFieldCapability(widget, key) {
+  return widget.fields.find((field) => field.key === key);
+}
+function findCustomCapability(widget, type, name) {
+  var _a;
+  return (_a = widget.customTypes.find((item) => item.type === type)) == null ? void 0 : _a.capabilities.find((capability) => capability.name === name);
+}
+
+// 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(widget, key, value, scopeMode, path, issues) {
+  const field = findFieldCapability(widget, key);
+  if (!field) {
+    issues.push({
+      code: "unknown_prop",
+      path,
+      message: `${widget.type} \u6CA1\u6709\u767B\u8BB0\u6807\u51C6\u5B57\u6BB5 ${key}`
+    });
+    return false;
+  }
+  if (field.readOnly) {
+    issues.push({
+      code: "read_only_prop",
+      path,
+      message: `${widget.type}.${key} \u4E3A\u53EA\u8BFB\u5B57\u6BB5`
+    });
+    return false;
+  }
+  if (!allowsScope(scopeMode, field.scope)) {
+    issues.push({
+      code: "scope_violation",
+      path,
+      message: `${widget.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: `${widget.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: `${widget.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: `${widget.type}.${key} \u4E0D\u80FD\u5927\u4E8E ${field.maximum}`
+    });
+    return false;
+  }
+  return true;
+}
+function validateProps(widget, 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(widget, key);
+    if (field && container === "props" && field.scope === "style") {
+      issues.push({
+        code: "style_field_in_props",
+        path: `${path}.${key}`,
+        message: `${widget.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: `${widget.type}.${key} \u4E0D\u662F\u6837\u5F0F\u5B57\u6BB5\uFF0C\u4E0D\u80FD\u5199\u5165 style`
+      });
+      return;
+    }
+    validateFieldValue(widget, key, value, scopeMode, `${path}.${key}`, issues);
+  });
+}
+function validateCustom(widget, 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(widget, type, name);
+    if (!capability) {
+      issues.push({
+        code: "unsupported_capability",
+        path: `${path}[${index}]`,
+        message: `${widget.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 widgetType = typeof operation.widget === "string" ? operation.widget : "";
+      const widget2 = findWidgetCapability(options.catalog, widgetType);
+      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 (!widget2) {
+        issues.push({
+          code: "unknown_widget",
+          path: `${path}.widget`,
+          message: `\u7EC4\u4EF6\u80FD\u529B\u76EE\u5F55\u4E2D\u4E0D\u5B58\u5728 ${widgetType}`
+        });
+      }
+      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 (widget2) {
+        const customOperations = operation.custom === void 0 ? [] : operation.custom;
+        validateProps(widget2, operation.props, "props", scopeMode, `${path}.props`, issues);
+        validateProps(widget2, operation.style, "style", scopeMode, `${path}.style`, issues);
+        validateCustom(widget2, customOperations, scopeMode, `${path}.custom`, issues);
+      }
+      if (key)
+        addKeys.add(key);
+      normalizedOperations.push({
+        op,
+        key,
+        widget: widgetType,
+        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 widget = node ? findWidgetCapability(options.catalog, node.type) : void 0;
+    if (node && widget) {
+      validateProps(widget, operation.props, "props", scopeMode, `${path}.props`, issues);
+      validateProps(widget, operation.style, "style", scopeMode, `${path}.style`, issues);
+      validateCustom(widget, 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(widget, key) {
+  var _a;
+  return ((_a = findFieldCapability(widget, key)) == null ? void 0 : _a.scope) === "style";
+}
+function isKnownScope(value) {
+  return isScope(value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isKnownScope,
+  isStyleField,
+  validateEditorDsl
+});

package/dist/dsl.d.cts

@@ -0,0 +1,85 @@
+import { j as CapabilityCatalog, i as WidgetCapability, F as FieldScope } from './capability-Ce3qGTm3.cjs';
+import 'element-plus';
+import 'vue';
+import 'async-validator';
+
+type DslScopeMode = 'style_only' | 'content_only' | 'layout_only' | 'any';
+interface DslScope {
+    mode: DslScopeMode;
+    targets: string[];
+}
+interface DslPlacement {
+    afterUuid?: string;
+    beforeUuid?: string;
+    afterKey?: string;
+    beforeKey?: string;
+    group?: string;
+}
+interface DslCustomOperation {
+    type: string;
+    capability: string;
+    args: Record<string, unknown>;
+}
+interface DslAddOperation {
+    op: 'add';
+    key: string;
+    widget: string;
+    placement?: DslPlacement;
+    props?: Record<string, unknown>;
+    style?: Record<string, unknown>;
+    custom?: DslCustomOperation[];
+}
+interface DslUpdateOperation {
+    op: 'update';
+    uuid: string;
+    props?: Record<string, unknown>;
+    style?: Record<string, unknown>;
+    custom?: DslCustomOperation[];
+}
+interface DslDeleteOperation {
+    op: 'delete';
+    uuid: string;
+    confirmToken?: string;
+}
+type DslOperation = DslAddOperation | DslUpdateOperation | DslDeleteOperation;
+interface EditorDsl {
+    dslVersion: '1.1';
+    baseRevision: number;
+    scope: DslScope;
+    operations: DslOperation[];
+}
+interface DslNodeSummary {
+    uuid: string;
+    type: string;
+    parentUuid?: string;
+}
+interface DslDocumentSnapshot {
+    revision: number;
+    nodes: DslNodeSummary[];
+    /** Tokens issued by the host after previewing destructive operations. */
+    confirmTokens?: string[];
+}
+interface DslIssue {
+    code: string;
+    path: string;
+    message: string;
+}
+interface DslValidationResult {
+    ok: boolean;
+    issues: DslIssue[];
+    normalized?: EditorDsl;
+}
+interface DslValidationOptions {
+    catalog: CapabilityCatalog;
+    snapshot: DslDocumentSnapshot;
+}
+/**
+ * Deterministic, side-effect-free validation for the versioned editor DSL.
+ * The host must validate before applying; the executor repeats critical checks
+ * against the live document.
+ */
+declare function validateEditorDsl(input: unknown, options: DslValidationOptions): DslValidationResult;
+declare function isStyleField(widget: WidgetCapability, key: string): boolean;
+declare function isKnownScope(value: unknown): value is FieldScope;
+
+export { type DslAddOperation, type DslCustomOperation, type DslDeleteOperation, type DslDocumentSnapshot, type DslIssue, type DslNodeSummary, type DslOperation, type DslPlacement, type DslScope, type DslScopeMode, type DslUpdateOperation, type DslValidationOptions, type DslValidationResult, type EditorDsl, isKnownScope, isStyleField, validateEditorDsl };

package/dist/dsl.d.ts

@@ -0,0 +1,85 @@
+import { j as CapabilityCatalog, i as WidgetCapability, F as FieldScope } from './capability-Ce3qGTm3.js';
+import 'element-plus';
+import 'vue';
+import 'async-validator';
+
+type DslScopeMode = 'style_only' | 'content_only' | 'layout_only' | 'any';
+interface DslScope {
+    mode: DslScopeMode;
+    targets: string[];
+}
+interface DslPlacement {
+    afterUuid?: string;
+    beforeUuid?: string;
+    afterKey?: string;
+    beforeKey?: string;
+    group?: string;
+}
+interface DslCustomOperation {
+    type: string;
+    capability: string;
+    args: Record<string, unknown>;
+}
+interface DslAddOperation {
+    op: 'add';
+    key: string;
+    widget: string;
+    placement?: DslPlacement;
+    props?: Record<string, unknown>;
+    style?: Record<string, unknown>;
+    custom?: DslCustomOperation[];
+}
+interface DslUpdateOperation {
+    op: 'update';
+    uuid: string;
+    props?: Record<string, unknown>;
+    style?: Record<string, unknown>;
+    custom?: DslCustomOperation[];
+}
+interface DslDeleteOperation {
+    op: 'delete';
+    uuid: string;
+    confirmToken?: string;
+}
+type DslOperation = DslAddOperation | DslUpdateOperation | DslDeleteOperation;
+interface EditorDsl {
+    dslVersion: '1.1';
+    baseRevision: number;
+    scope: DslScope;
+    operations: DslOperation[];
+}
+interface DslNodeSummary {
+    uuid: string;
+    type: string;
+    parentUuid?: string;
+}
+interface DslDocumentSnapshot {
+    revision: number;
+    nodes: DslNodeSummary[];
+    /** Tokens issued by the host after previewing destructive operations. */
+    confirmTokens?: string[];
+}
+interface DslIssue {
+    code: string;
+    path: string;
+    message: string;
+}
+interface DslValidationResult {
+    ok: boolean;
+    issues: DslIssue[];
+    normalized?: EditorDsl;
+}
+interface DslValidationOptions {
+    catalog: CapabilityCatalog;
+    snapshot: DslDocumentSnapshot;
+}
+/**
+ * Deterministic, side-effect-free validation for the versioned editor DSL.
+ * The host must validate before applying; the executor repeats critical checks
+ * against the live document.
+ */
+declare function validateEditorDsl(input: unknown, options: DslValidationOptions): DslValidationResult;
+declare function isStyleField(widget: WidgetCapability, key: string): boolean;
+declare function isKnownScope(value: unknown): value is FieldScope;
+
+export { type DslAddOperation, type DslCustomOperation, type DslDeleteOperation, type DslDocumentSnapshot, type DslIssue, type DslNodeSummary, type DslOperation, type DslPlacement, type DslScope, type DslScopeMode, type DslUpdateOperation, type DslValidationOptions, type DslValidationResult, type EditorDsl, isKnownScope, isStyleField, validateEditorDsl };

package/dist/dsl.js

@@ -0,0 +1,12 @@
+import {
+  isKnownScope,
+  isStyleField,
+  validateEditorDsl
+} from "./chunk-W7WBD3NX.js";
+import "./chunk-XXR7SKZ3.js";
+import "./chunk-6FNC3XMI.js";
+export {
+  isKnownScope,
+  isStyleField,
+  validateEditorDsl
+};

package/dist/helper/index.cjs

@@ -89,6 +89,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),

package/dist/helper/index.d.cts

@@ -2,6 +2,6 @@ export { EventEmitter } from './EventEmitter.cjs';
 export { schema } from './schema.cjs';
 export { widget, widgetType } from './widget.cjs';
 import 'element-plus';
-import '../Node-B7pDsvZF.cjs';
+import '../capability-Ce3qGTm3.cjs';
 import 'vue';
 import 'async-validator';

package/dist/helper/index.d.ts

@@ -2,6 +2,6 @@ export { EventEmitter } from './EventEmitter.js';
 export { schema } from './schema.js';
 export { widget, widgetType } from './widget.js';
 import 'element-plus';
-import '../Node-B7pDsvZF.js';
+import '../capability-Ce3qGTm3.js';
 import 'vue';
 import 'async-validator';

package/dist/helper/index.js

@@ -4,7 +4,7 @@ import {
 } from "../chunk-W776G2UQ.js";
 import {
   schema
-} from "../chunk-PRK4NPVH.js";
+} from "../chunk-62FPS6PZ.js";
 import {
   widget,
   widgetType

package/dist/helper/schema.cjs

@@ -53,6 +53,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),

package/dist/helper/schema.d.cts

@@ -1,5 +1,5 @@
 import { FormItemProps, InputProps, InputNumberProps, CheckboxProps, SelectProps, RadioProps, RadioButtonProps, SwitchProps, DatePickerProps, ColorPickerProps } from 'element-plus';
-import { l as SchemaItem, O as Option, R as RadioOption, m as RadioButtonOption } from '../Node-B7pDsvZF.cjs';
+import { b as SchemaItem, F as FieldScope, O as Option, R as RadioOption, a as RadioButtonOption } from '../capability-Ce3qGTm3.cjs';
 import 'vue';
 import 'async-validator';
 
@@ -8,6 +8,8 @@ interface BaseConfig {
     _role?: string;
     label: SchemaItem['label'];
     key: SchemaItem['key'];
+    scope?: FieldScope;
+    readOnly?: boolean;
     tips?: string;
     formItem?: Partial<FormItemProps>;
     required?: boolean | string;

package/dist/helper/schema.d.ts

@@ -1,5 +1,5 @@
 import { FormItemProps, InputProps, InputNumberProps, CheckboxProps, SelectProps, RadioProps, RadioButtonProps, SwitchProps, DatePickerProps, ColorPickerProps } from 'element-plus';
-import { l as SchemaItem, O as Option, R as RadioOption, m as RadioButtonOption } from '../Node-B7pDsvZF.js';
+import { b as SchemaItem, F as FieldScope, O as Option, R as RadioOption, a as RadioButtonOption } from '../capability-Ce3qGTm3.js';
 import 'vue';
 import 'async-validator';
 
@@ -8,6 +8,8 @@ interface BaseConfig {
     _role?: string;
     label: SchemaItem['label'];
     key: SchemaItem['key'];
+    scope?: FieldScope;
+    readOnly?: boolean;
     tips?: string;
     formItem?: Partial<FormItemProps>;
     required?: boolean | string;

package/dist/helper/schema.js

@@ -1,6 +1,6 @@
 import {
   schema
-} from "../chunk-PRK4NPVH.js";
+} from "../chunk-62FPS6PZ.js";
 import "../chunk-XJ2IJHKH.js";
 import "../chunk-6FNC3XMI.js";
 export {

package/dist/helper/widget.d.cts

@@ -1,4 +1,4 @@
-import { I as IWidget, l as SchemaItem, W as WidgetPos, b as WidgetAgent, B as Base } from '../Node-B7pDsvZF.cjs';
+import { I as IWidget, b as SchemaItem, p as WidgetPos, t as WidgetAgent, B as Base } from '../capability-Ce3qGTm3.cjs';
 import * as vue from 'vue';
 import 'element-plus';
 import 'async-validator';