@sepveneto/dnde-core 0.6.4 → 0.6.5

package/dist/capability.cjs

@@ -0,0 +1,172 @@
+"use strict";
+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 __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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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/capability.ts
+var capability_exports = {};
+__export(capability_exports, {
+  createCapabilityCatalog: () => createCapabilityCatalog,
+  findCustomCapability: () => findCustomCapability,
+  findFieldCapability: () => findFieldCapability,
+  findWidgetCapability: () => findWidgetCapability,
+  listStaticOptions: () => listStaticOptions
+});
+module.exports = __toCommonJS(capability_exports);
+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(widget) {
+  var _a, _b;
+  return ((_b = (_a = widget.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 widget of widgets) {
+    const registration = registry[widget._view];
+    const declared = registeredCustomTypes(registration);
+    const declaredMap = new Map(declared.map((type) => [type.type, type]));
+    const customTypes = schemaCustomTypes(widget).map((type) => {
+      var _a2;
+      return (_a2 = declaredMap.get(type)) != null ? _a2 : { type, capabilities: [] };
+    });
+    catalog.widgets.push({
+      type: widget._view,
+      name: widget._name,
+      description: (_e = (_d = (_a = widget.agent) == null ? void 0 : _a.description) != null ? _d : (_c = (_b = widget.agent) == null ? void 0 : _b.layout) == null ? void 0 : _c.description) != null ? _e : "",
+      defaultData: JSON.parse(JSON.stringify((_f = widget.data) != null ? _f : {})),
+      defaultStyle: JSON.parse(JSON.stringify((_g = widget.style) != null ? _g : {})),
+      fields: [
+        ...((_i = (_h = widget.schema) == null ? void 0 : _h.props) != null ? _i : []).map((item) => fieldFromSchema(item, "content")).filter((item) => Boolean(item)),
+        ...((_k = (_j = widget.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((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);
+}
+function listStaticOptions(catalog, widgetTypes, types) {
+  const selected = (widgetTypes == null ? void 0 : widgetTypes.length) ? catalog.widgets.filter((widget) => widgetTypes.includes(widget.type)) : catalog.widgets;
+  return selected.flatMap((widget) => widget.staticOptions).filter((option) => !(types == null ? void 0 : types.length) || option.types.some((type) => types.includes(type)));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCapabilityCatalog,
+  findCustomCapability,
+  findFieldCapability,
+  findWidgetCapability,
+  listStaticOptions
+});

package/dist/capability.d.cts

@@ -0,0 +1,4 @@
+export { j as CapabilityCatalog, C as CapabilityValueType, F as FieldScope, f as StaticOption, i as WidgetCapability, g as WidgetCapabilityRegistration, h as WidgetCapabilityRegistry, d as WidgetCustomCapability, e as WidgetCustomTypeCapability, c as WidgetFieldCapability, k as createCapabilityCatalog, n as findCustomCapability, m as findFieldCapability, l as findWidgetCapability, o as listStaticOptions } from './capability-Ce3qGTm3.cjs';
+import 'element-plus';
+import 'vue';
+import 'async-validator';

package/dist/capability.d.ts

@@ -0,0 +1,4 @@
+export { j as CapabilityCatalog, C as CapabilityValueType, F as FieldScope, f as StaticOption, i as WidgetCapability, g as WidgetCapabilityRegistration, h as WidgetCapabilityRegistry, d as WidgetCustomCapability, e as WidgetCustomTypeCapability, c as WidgetFieldCapability, k as createCapabilityCatalog, n as findCustomCapability, m as findFieldCapability, l as findWidgetCapability, o as listStaticOptions } from './capability-Ce3qGTm3.js';
+import 'element-plus';
+import 'vue';
+import 'async-validator';

package/dist/capability.js

@@ -0,0 +1,15 @@
+import {
+  createCapabilityCatalog,
+  findCustomCapability,
+  findFieldCapability,
+  findWidgetCapability,
+  listStaticOptions
+} from "./chunk-XXR7SKZ3.js";
+import "./chunk-6FNC3XMI.js";
+export {
+  createCapabilityCatalog,
+  findCustomCapability,
+  findFieldCapability,
+  findWidgetCapability,
+  listStaticOptions
+};

package/dist/{chunk-PRK4NPVH.js → chunk-62FPS6PZ.js}

@@ -13,6 +13,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/chunk-W7WBD3NX.js

@@ -0,0 +1,360 @@
+import {
+  findCustomCapability,
+  findFieldCapability,
+  findWidgetCapability
+} from "./chunk-XXR7SKZ3.js";
+import {
+  __spreadValues
+} from "./chunk-6FNC3XMI.js";
+
+// 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);
+}
+
+export {
+  validateEditorDsl,
+  isStyleField,
+  isKnownScope
+};