@nocobase/flow-engine 2.1.0-alpha.10 → 2.1.0-alpha.12

package/lib/components/subModel/AddSubModelButton.js

@@ -476,6 +476,17 @@ const AddSubModelButtonCore = /* @__PURE__ */ __name(function AddSubModelButton(
     () => transformItems(finalItems, model, subModelKey, subModelType),
     [finalItems, model, subModelKey, subModelType]
   );
+  (0, import_react.useEffect)(() => {
+    const handleSubModelChange = /* @__PURE__ */ __name(() => {
+      setRefreshTick((x) => x + 1);
+    }, "handleSubModelChange");
+    model.emitter.on("onSubModelAdded", handleSubModelChange);
+    model.emitter.on("onSubModelRemoved", handleSubModelChange);
+    return () => {
+      model.emitter.off("onSubModelAdded", handleSubModelChange);
+      model.emitter.off("onSubModelRemoved", handleSubModelChange);
+    };
+  }, [model]);
   return /* @__PURE__ */ import_react.default.createElement(
     import_LazyDropdown.default,
     {

package/lib/flow-schema-registry/fieldBinding.d.ts

@@ -0,0 +1,32 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { FlowFieldBindingConditions, FlowFieldBindingContextContribution, FlowFieldBindingContribution, FlowFieldModelCompatibility, FlowSchemaCoverage } from '../types';
+export type RegisteredFieldBindingContext = {
+    name: string;
+    inherits: string[];
+};
+export type RegisteredFieldBinding = {
+    context: string;
+    use: string;
+    interfaces: string[];
+    isDefault: boolean;
+    order?: number;
+    conditions?: FlowFieldBindingConditions;
+    defaultProps?: any;
+    source: FlowSchemaCoverage['source'];
+};
+export declare function normalizeFieldBindingContextContribution(contribution?: FlowFieldBindingContextContribution, fallbackName?: string): RegisteredFieldBindingContext | undefined;
+export declare function normalizeFieldBindingContribution(contribution?: FlowFieldBindingContribution, source?: FlowSchemaCoverage['source']): RegisteredFieldBinding | undefined;
+export declare function matchesFieldBinding(binding: RegisteredFieldBinding, options: {
+    interface?: string;
+    fieldType?: string;
+    association?: boolean;
+    targetCollectionTemplate?: string;
+}): boolean;
+export declare function buildFieldModelCompatibility(binding: RegisteredFieldBinding): FlowFieldModelCompatibility;

package/lib/flow-schema-registry/fieldBinding.js

@@ -0,0 +1,165 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __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 fieldBinding_exports = {};
+__export(fieldBinding_exports, {
+  buildFieldModelCompatibility: () => buildFieldModelCompatibility,
+  matchesFieldBinding: () => matchesFieldBinding,
+  normalizeFieldBindingContextContribution: () => normalizeFieldBindingContextContribution,
+  normalizeFieldBindingContribution: () => normalizeFieldBindingContribution
+});
+module.exports = __toCommonJS(fieldBinding_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_utils = require("./utils");
+function normalizeFieldBindingConditions(conditions) {
+  if (!conditions || typeof conditions !== "object" || Array.isArray(conditions)) {
+    return void 0;
+  }
+  const normalized = import_lodash.default.pickBy(
+    {
+      association: typeof conditions.association === "boolean" ? conditions.association : void 0,
+      fieldTypes: (0, import_utils.normalizeStringArray)(conditions.fieldTypes),
+      targetCollectionTemplateIn: (0, import_utils.normalizeStringArray)(conditions.targetCollectionTemplateIn),
+      targetCollectionTemplateNotIn: (0, import_utils.normalizeStringArray)(conditions.targetCollectionTemplateNotIn)
+    },
+    (value) => {
+      if (Array.isArray(value)) {
+        return value.length > 0;
+      }
+      return value !== void 0;
+    }
+  );
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+__name(normalizeFieldBindingConditions, "normalizeFieldBindingConditions");
+function normalizeFieldBindingContextContribution(contribution, fallbackName) {
+  const name = String((contribution == null ? void 0 : contribution.name) || fallbackName || "").trim();
+  if (!name) {
+    return void 0;
+  }
+  return {
+    name,
+    inherits: (0, import_utils.normalizeStringArray)(contribution == null ? void 0 : contribution.inherits)
+  };
+}
+__name(normalizeFieldBindingContextContribution, "normalizeFieldBindingContextContribution");
+function normalizeFieldBindingContribution(contribution, source = "official") {
+  const context = String((contribution == null ? void 0 : contribution.context) || "").trim();
+  const use = String((contribution == null ? void 0 : contribution.use) || "").trim();
+  const interfaces = (0, import_utils.normalizeStringArray)(contribution == null ? void 0 : contribution.interfaces);
+  if (!context || !use || interfaces.length === 0) {
+    return void 0;
+  }
+  return {
+    context,
+    use,
+    interfaces,
+    isDefault: (contribution == null ? void 0 : contribution.isDefault) === true,
+    order: typeof (contribution == null ? void 0 : contribution.order) === "number" ? contribution.order : void 0,
+    conditions: normalizeFieldBindingConditions(contribution == null ? void 0 : contribution.conditions),
+    defaultProps: (contribution == null ? void 0 : contribution.defaultProps) === void 0 ? void 0 : import_lodash.default.cloneDeep(contribution.defaultProps),
+    source
+  };
+}
+__name(normalizeFieldBindingContribution, "normalizeFieldBindingContribution");
+function matchesFieldBinding(binding, options) {
+  var _a, _b, _c;
+  if (options.interface && !binding.interfaces.includes("*") && !binding.interfaces.includes(options.interface)) {
+    return false;
+  }
+  const conditions = binding.conditions;
+  if (!conditions) {
+    return true;
+  }
+  if (typeof conditions.association === "boolean" && options.association !== void 0) {
+    if (conditions.association !== options.association) {
+      return false;
+    }
+  }
+  if (((_a = conditions.fieldTypes) == null ? void 0 : _a.length) && options.fieldType) {
+    if (!conditions.fieldTypes.includes(options.fieldType)) {
+      return false;
+    }
+  }
+  if (((_b = conditions.targetCollectionTemplateIn) == null ? void 0 : _b.length) && options.targetCollectionTemplate) {
+    if (!conditions.targetCollectionTemplateIn.includes(options.targetCollectionTemplate)) {
+      return false;
+    }
+  }
+  if (((_c = conditions.targetCollectionTemplateNotIn) == null ? void 0 : _c.length) && options.targetCollectionTemplate) {
+    if (conditions.targetCollectionTemplateNotIn.includes(options.targetCollectionTemplate)) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(matchesFieldBinding, "matchesFieldBinding");
+function buildFieldModelCompatibility(binding) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const compatibility = {
+    context: binding.context,
+    interfaces: import_lodash.default.cloneDeep(binding.interfaces),
+    inheritParentFieldBinding: true
+  };
+  if (binding.isDefault) {
+    compatibility.isDefault = true;
+  }
+  if (typeof binding.order === "number") {
+    compatibility.order = binding.order;
+  }
+  if (typeof ((_a = binding.conditions) == null ? void 0 : _a.association) === "boolean") {
+    compatibility.association = binding.conditions.association;
+  }
+  if ((_c = (_b = binding.conditions) == null ? void 0 : _b.fieldTypes) == null ? void 0 : _c.length) {
+    compatibility.fieldTypes = import_lodash.default.cloneDeep(binding.conditions.fieldTypes);
+  }
+  if ((_e = (_d = binding.conditions) == null ? void 0 : _d.targetCollectionTemplateIn) == null ? void 0 : _e.length) {
+    compatibility.targetCollectionTemplateIn = import_lodash.default.cloneDeep(binding.conditions.targetCollectionTemplateIn);
+  }
+  if ((_g = (_f = binding.conditions) == null ? void 0 : _f.targetCollectionTemplateNotIn) == null ? void 0 : _g.length) {
+    compatibility.targetCollectionTemplateNotIn = import_lodash.default.cloneDeep(binding.conditions.targetCollectionTemplateNotIn);
+  }
+  return compatibility;
+}
+__name(buildFieldModelCompatibility, "buildFieldModelCompatibility");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildFieldModelCompatibility,
+  matchesFieldBinding,
+  normalizeFieldBindingContextContribution,
+  normalizeFieldBindingContribution
+});

package/lib/flow-schema-registry/modelPatches.d.ts

@@ -0,0 +1,16 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { FlowDescendantSchemaPatch, FlowModelSchemaPatch, FlowSchemaContextEdge, FlowSchemaCoverage, FlowSubModelContextPathStep, FlowSubModelSlotSchema } from '../types';
+import type { RegisteredModelSchema } from '../FlowSchemaRegistry';
+export declare function normalizeSubModelContextPath(path?: FlowSubModelContextPathStep[]): FlowSubModelContextPathStep[];
+export declare function normalizeModelSchemaPatch(patch?: FlowModelSchemaPatch): FlowModelSchemaPatch | undefined;
+export declare function normalizeSubModelSlots(slots?: Record<string, FlowSubModelSlotSchema>): Record<string, FlowSubModelSlotSchema> | undefined;
+export declare function matchesDescendantSchemaPatch(patch: FlowDescendantSchemaPatch, remainingEdges: FlowSchemaContextEdge[]): boolean;
+export declare function resolveChildSchemaPatch(slot: FlowSubModelSlotSchema, childUse: string): FlowModelSchemaPatch | undefined;
+export declare function applyModelSchemaPatch(target: RegisteredModelSchema, patch: FlowModelSchemaPatch, source: FlowSchemaCoverage['source'], strict?: boolean): void;

package/lib/flow-schema-registry/modelPatches.js

@@ -0,0 +1,235 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __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 modelPatches_exports = {};
+__export(modelPatches_exports, {
+  applyModelSchemaPatch: () => applyModelSchemaPatch,
+  matchesDescendantSchemaPatch: () => matchesDescendantSchemaPatch,
+  normalizeModelSchemaPatch: () => normalizeModelSchemaPatch,
+  normalizeSubModelContextPath: () => normalizeSubModelContextPath,
+  normalizeSubModelSlots: () => normalizeSubModelSlots,
+  resolveChildSchemaPatch: () => resolveChildSchemaPatch
+});
+module.exports = __toCommonJS(modelPatches_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_utils = require("./utils");
+function normalizeSubModelContextPath(path) {
+  if (!Array.isArray(path)) {
+    return [];
+  }
+  return path.map((step) => ({
+    slotKey: String((step == null ? void 0 : step.slotKey) || "").trim(),
+    ...typeof (step == null ? void 0 : step.use) === "string" ? { use: step.use.trim() } : Array.isArray(step == null ? void 0 : step.use) ? { use: step.use.map((item) => String(item || "").trim()).filter(Boolean) } : {}
+  })).filter((step) => !!step.slotKey);
+}
+__name(normalizeSubModelContextPath, "normalizeSubModelContextPath");
+function normalizeModelSchemaPatch(patch) {
+  if (!patch || typeof patch !== "object" || Array.isArray(patch)) {
+    return void 0;
+  }
+  const normalized = import_lodash.default.pickBy(
+    {
+      stepParamsSchema: patch.stepParamsSchema ? import_lodash.default.cloneDeep(patch.stepParamsSchema) : void 0,
+      flowRegistrySchema: patch.flowRegistrySchema ? import_lodash.default.cloneDeep(patch.flowRegistrySchema) : void 0,
+      flowRegistrySchemaPatch: patch.flowRegistrySchemaPatch ? import_lodash.default.cloneDeep(patch.flowRegistrySchemaPatch) : void 0,
+      subModelSlots: normalizeSubModelSlots(patch.subModelSlots),
+      docs: patch.docs ? (0, import_utils.normalizeSchemaDocs)(patch.docs) : void 0,
+      examples: Array.isArray(patch.examples) ? import_lodash.default.cloneDeep(patch.examples) : void 0,
+      skeleton: patch.skeleton === void 0 ? void 0 : import_lodash.default.cloneDeep(patch.skeleton),
+      dynamicHints: Array.isArray(patch.dynamicHints) ? (0, import_utils.normalizeSchemaHints)(patch.dynamicHints) : void 0
+    },
+    (value) => value !== void 0 && (!Array.isArray(value) || value.length > 0)
+  );
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+__name(normalizeModelSchemaPatch, "normalizeModelSchemaPatch");
+function normalizeDescendantSchemaPatches(patches) {
+  if (!Array.isArray(patches)) {
+    return void 0;
+  }
+  const normalized = patches.map((item) => {
+    const path = normalizeSubModelContextPath(item == null ? void 0 : item.path);
+    const patch = normalizeModelSchemaPatch(item == null ? void 0 : item.patch);
+    if (!patch) {
+      return void 0;
+    }
+    return { path, patch };
+  }).filter(Boolean);
+  return normalized.length > 0 ? normalized : void 0;
+}
+__name(normalizeDescendantSchemaPatches, "normalizeDescendantSchemaPatches");
+function normalizeChildSchemaPatch(patch) {
+  if (!patch || typeof patch !== "object" || Array.isArray(patch)) {
+    return void 0;
+  }
+  const directPatch = normalizeModelSchemaPatch(patch);
+  if (directPatch) {
+    return directPatch;
+  }
+  const entries = Object.entries(patch).map(([childUse, childPatch]) => [String(childUse || "").trim(), normalizeModelSchemaPatch(childPatch)]).filter(([childUse, childPatch]) => !!childUse && !!childPatch);
+  if (!entries.length) {
+    return void 0;
+  }
+  return Object.fromEntries(entries);
+}
+__name(normalizeChildSchemaPatch, "normalizeChildSchemaPatch");
+function normalizeSubModelSlots(slots) {
+  if (!slots || typeof slots !== "object" || Array.isArray(slots)) {
+    return void 0;
+  }
+  const normalizedEntries = Object.entries(slots).map(([slotKey, slot]) => {
+    if (!(slot == null ? void 0 : slot.type)) {
+      return void 0;
+    }
+    const normalizedSlot = {
+      type: slot.type
+    };
+    const normalizedUse = typeof slot.use === "string" ? slot.use.trim() : void 0;
+    if (normalizedUse) {
+      normalizedSlot.use = normalizedUse;
+    }
+    const normalizedUses = Array.isArray(slot.uses) ? slot.uses.map((item) => String(item || "").trim()).filter(Boolean) : void 0;
+    if (normalizedUses == null ? void 0 : normalizedUses.length) {
+      normalizedSlot.uses = normalizedUses;
+    }
+    if (slot.required !== void 0) {
+      normalizedSlot.required = slot.required;
+    }
+    if (slot.type === "array" && typeof slot.minItems === "number" && Number.isFinite(slot.minItems)) {
+      normalizedSlot.minItems = Math.max(0, Math.trunc(slot.minItems));
+    }
+    if (slot.dynamic !== void 0) {
+      normalizedSlot.dynamic = slot.dynamic;
+    }
+    if (slot.schema) {
+      normalizedSlot.schema = import_lodash.default.cloneDeep(slot.schema);
+    }
+    if (typeof slot.fieldBindingContext === "string" && slot.fieldBindingContext.trim()) {
+      normalizedSlot.fieldBindingContext = slot.fieldBindingContext.trim();
+    }
+    const childSchemaPatch = normalizeChildSchemaPatch(slot.childSchemaPatch);
+    if (childSchemaPatch) {
+      normalizedSlot.childSchemaPatch = childSchemaPatch;
+    }
+    const descendantSchemaPatches = normalizeDescendantSchemaPatches(slot.descendantSchemaPatches);
+    if (descendantSchemaPatches == null ? void 0 : descendantSchemaPatches.length) {
+      normalizedSlot.descendantSchemaPatches = descendantSchemaPatches;
+    }
+    if (slot.description !== void 0) {
+      normalizedSlot.description = slot.description;
+    }
+    return [slotKey, normalizedSlot];
+  }).filter(Boolean);
+  return normalizedEntries.length > 0 ? Object.fromEntries(normalizedEntries) : void 0;
+}
+__name(normalizeSubModelSlots, "normalizeSubModelSlots");
+function matchesDescendantSchemaPatch(patch, remainingEdges) {
+  const path = normalizeSubModelContextPath(patch.path);
+  if (path.length !== remainingEdges.length) {
+    return false;
+  }
+  return path.every((step, index) => {
+    const edge = remainingEdges[index];
+    if (step.slotKey !== edge.slotKey) {
+      return false;
+    }
+    if (typeof step.use === "undefined") {
+      return true;
+    }
+    if (typeof step.use === "string") {
+      return step.use === edge.childUse;
+    }
+    return step.use.includes(edge.childUse);
+  });
+}
+__name(matchesDescendantSchemaPatch, "matchesDescendantSchemaPatch");
+function resolveChildSchemaPatch(slot, childUse) {
+  const childSchemaPatch = slot.childSchemaPatch;
+  if (!childSchemaPatch || typeof childSchemaPatch !== "object" || Array.isArray(childSchemaPatch)) {
+    return void 0;
+  }
+  const directPatch = normalizeModelSchemaPatch(childSchemaPatch);
+  if (directPatch) {
+    return directPatch;
+  }
+  return normalizeModelSchemaPatch(childSchemaPatch[childUse]);
+}
+__name(resolveChildSchemaPatch, "resolveChildSchemaPatch");
+function applyModelSchemaPatch(target, patch, source, strict) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  target.stepParamsSchema = (0, import_utils.mergeSchemas)(target.stepParamsSchema, patch.stepParamsSchema);
+  target.flowRegistrySchema = (0, import_utils.mergeSchemas)(target.flowRegistrySchema, patch.flowRegistrySchema);
+  target.flowRegistrySchemaPatch = (0, import_utils.mergeSchemas)(target.flowRegistrySchemaPatch, patch.flowRegistrySchemaPatch);
+  target.subModelSlots = normalizeSubModelSlots(
+    patch.subModelSlots ? (0, import_utils.deepMergeReplaceArrays)(target.subModelSlots || {}, patch.subModelSlots) : target.subModelSlots
+  );
+  target.docs = (0, import_utils.normalizeSchemaDocs)({
+    ...target.docs,
+    ...patch.docs,
+    examples: ((_a = patch.docs) == null ? void 0 : _a.examples) || ((_b = target.docs) == null ? void 0 : _b.examples),
+    dynamicHints: [...((_c = target.docs) == null ? void 0 : _c.dynamicHints) || [], ...((_d = patch.docs) == null ? void 0 : _d.dynamicHints) || []],
+    commonPatterns: ((_e = patch.docs) == null ? void 0 : _e.commonPatterns) || ((_f = target.docs) == null ? void 0 : _f.commonPatterns),
+    antiPatterns: ((_g = patch.docs) == null ? void 0 : _g.antiPatterns) || ((_h = target.docs) == null ? void 0 : _h.antiPatterns),
+    minimalExample: ((_i = patch.docs) == null ? void 0 : _i.minimalExample) !== void 0 ? patch.docs.minimalExample : (_j = target.docs) == null ? void 0 : _j.minimalExample
+  });
+  target.examples = Array.isArray(patch.examples) ? import_lodash.default.cloneDeep(patch.examples) : target.examples;
+  target.skeleton = patch.skeleton !== void 0 ? (0, import_utils.deepMergeReplaceArrays)(target.skeleton, patch.skeleton) : target.skeleton;
+  target.dynamicHints = (0, import_utils.normalizeSchemaHints)([
+    ...target.dynamicHints || [],
+    ...patch.dynamicHints || [],
+    ...((_k = patch.docs) == null ? void 0 : _k.dynamicHints) || []
+  ]);
+  const hasSchemaPatch = !!patch.stepParamsSchema || !!patch.flowRegistrySchema || !!patch.flowRegistrySchemaPatch || !!patch.subModelSlots;
+  if (hasSchemaPatch) {
+    target.coverage = {
+      ...target.coverage,
+      status: target.coverage.status === "unresolved" ? "manual" : target.coverage.status === "auto" ? "mixed" : target.coverage.status,
+      source: target.coverage.source === "third-party" ? source : target.coverage.source,
+      strict: target.coverage.strict ?? strict
+    };
+  }
+}
+__name(applyModelSchemaPatch, "applyModelSchemaPatch");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyModelSchemaPatch,
+  matchesDescendantSchemaPatch,
+  normalizeModelSchemaPatch,
+  normalizeSubModelContextPath,
+  normalizeSubModelSlots,
+  resolveChildSchemaPatch
+});

package/lib/flow-schema-registry/schemaInference.d.ts

@@ -0,0 +1,17 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { ISchema } from '@formily/json-schema';
+import type { FlowDynamicHint, FlowJsonSchema, FlowSchemaCoverage } from '../types';
+export type StepSchemaResolution = {
+    schema?: FlowJsonSchema;
+    hints: FlowDynamicHint[];
+    coverage: FlowSchemaCoverage['status'];
+};
+export type UiSchemaLike = Record<string, ISchema> | ((...args: any[]) => Record<string, ISchema> | Promise<Record<string, ISchema>>) | undefined;
+export declare function inferParamsSchemaFromUiSchema(name: string, uiSchema: UiSchemaLike, path: string): StepSchemaResolution;