@nocobase/plugin-flow-engine 2.1.0-alpha.2 → 2.1.0-alpha.20

package/dist/server/flow-surfaces/executor.js

@@ -0,0 +1,132 @@
+/**
+ * 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 __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 executor_exports = {};
+__export(executor_exports, {
+  executeMutateOps: () => executeMutateOps,
+  inspectFlowSurfaceValueKey: () => inspectFlowSurfaceValueKey,
+  resolveFlowSurfaceValueKeys: () => resolveFlowSurfaceValueKeys
+});
+module.exports = __toCommonJS(executor_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("./errors");
+var import_reference_guards = require("./reference-guards");
+var import_created_keys = require("./planning/created-keys");
+async function executeMutateOps(ops, ctx, dispatcher) {
+  const results = [];
+  for (const op of ops) {
+    const resolvedValues = resolveFlowSurfaceValueKeys(
+      import_lodash.default.cloneDeep({
+        ...op.target ? { target: op.target } : {},
+        ...op.values || {}
+      }),
+      ctx.keys
+    );
+    const result = await dispatcher(op, resolvedValues, ctx);
+    if (op.opId) {
+      ctx.keys.set(op.opId, result);
+    }
+    results.push({ opId: op.opId, result });
+  }
+  return results;
+}
+function resolveFlowSurfaceValueKeys(input, keys) {
+  if (Array.isArray(input)) {
+    return input.map((item) => resolveFlowSurfaceValueKeys(item, keys));
+  }
+  if (import_lodash.default.isPlainObject(input)) {
+    (0, import_reference_guards.assertNoFlowSurfaceLegacyRef)(input, {
+      actionName: "mutate",
+      path: "values",
+      dollarRefAllowed: "{ key } or { step, path }",
+      refAllowed: "{ key } or { step, path }"
+    });
+    if ((0, import_reference_guards.isFlowSurfacePlanStepValue)(input)) {
+      return readStepResult(input, keys);
+    }
+    if ((0, import_created_keys.isFlowSurfacePureKeyObject)(input)) {
+      return readKey(input.key, keys);
+    }
+    return Object.fromEntries(
+      Object.entries(input).map(([key, value]) => [key, resolveFlowSurfaceValueKeys(value, keys)])
+    );
+  }
+  return input;
+}
+function inspectFlowSurfaceValueKey(path, keys) {
+  const trimmedPath = String(path || "").trim();
+  if (!trimmedPath) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate key cannot be empty`);
+  }
+  if (keys.has(trimmedPath)) {
+    return {
+      found: true,
+      value: keys.get(trimmedPath)
+    };
+  }
+  return {
+    found: false,
+    missingHead: trimmedPath
+  };
+}
+function readKey(path, keys) {
+  const resolved = inspectFlowSurfaceValueKey(path, keys);
+  if (!resolved.found) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate key '${resolved.missingHead}' not found`);
+  }
+  return resolved.value;
+}
+function readStepResult(input, keys) {
+  const step = String(input.step || "").trim();
+  if (!step) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate step cannot be empty`);
+  }
+  if (!keys.has(step)) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate step '${step}' not found`);
+  }
+  const value = keys.get(step);
+  const path = import_lodash.default.isUndefined(input.path) ? void 0 : String(input.path || "").trim();
+  if (import_lodash.default.has(input, "path") && !path) {
+    throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces mutate path cannot be empty`);
+  }
+  return path ? import_lodash.default.get(value, path) : value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  executeMutateOps,
+  inspectFlowSurfaceValueKey,
+  resolveFlowSurfaceValueKeys
+});

package/dist/server/flow-surfaces/field-binding-registry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+export type FlowSurfaceFieldBindingScope = 'display' | 'editable' | 'filter';
+export type FlowSurfaceFieldBindingResolution = {
+    modelClassName: string;
+    ownerPlugin?: string;
+    isDefault: boolean;
+};
+export declare function getRegisteredFieldUses(scope?: FlowSurfaceFieldBindingScope, enabledPackages?: ReadonlySet<string>): ReadonlySet<string>;
+export declare function resolveRegisteredFieldBinding(input: {
+    containerUse?: string;
+    field: any;
+    dataSourceKey?: string;
+    enabledPackages?: ReadonlySet<string>;
+    getCollection?: (dataSourceKey: string, collectionName: string) => any;
+    useStrictOnly?: boolean;
+}): FlowSurfaceFieldBindingResolution | null;

package/dist/server/flow-surfaces/field-binding-registry.js

@@ -0,0 +1,391 @@
+/**
+ * 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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var field_binding_registry_exports = {};
+__export(field_binding_registry_exports, {
+  getRegisteredFieldUses: () => getRegisteredFieldUses,
+  resolveRegisteredFieldBinding: () => resolveRegisteredFieldBinding
+});
+module.exports = __toCommonJS(field_binding_registry_exports);
+var import_field_semantics = require("./field-semantics");
+var import_service_helpers = require("./service-helpers");
+const FILE_MANAGER_PLUGIN = "@nocobase/plugin-file-manager";
+const ATTACHMENT_URL_PLUGIN = "@nocobase/plugin-field-attachment-url";
+const CODE_PLUGIN = "@nocobase/plugin-field-code";
+const FORMULA_PLUGIN = "@nocobase/plugin-field-formula";
+const CHINA_REGION_PLUGIN = "@nocobase/plugin-field-china-region";
+const MAP_PLUGIN = "@nocobase/plugin-map";
+const MARKDOWN_VDITOR_PLUGIN = "@nocobase/plugin-field-markdown-vditor";
+const SORT_PLUGIN = "@nocobase/plugin-field-sort";
+function getCollectionTemplate(collection) {
+  var _a;
+  return (collection == null ? void 0 : collection.template) || ((_a = collection == null ? void 0 : collection.options) == null ? void 0 : _a.template);
+}
+function isAttachmentInterface(field) {
+  return String((0, import_service_helpers.getFieldInterface)(field) || "").trim() === "attachment";
+}
+function getFieldDataType(field) {
+  var _a;
+  return (field == null ? void 0 : field.dataType) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.dataType);
+}
+function isNumericFormulaDataType(dataType) {
+  return ["integer", "bigInt", "double", "decimal", "number"].includes(String(dataType || "").trim());
+}
+function resolveTargetCollection(input) {
+  var _a;
+  if ((_a = input.field) == null ? void 0 : _a.targetCollection) {
+    return input.field.targetCollection;
+  }
+  if (!input.getCollection || !input.dataSourceKey) {
+    return null;
+  }
+  return (0, import_service_helpers.resolveFieldTargetCollection)(input.field, input.dataSourceKey, input.getCollection);
+}
+function normalizeBindingContainerUse(containerUse) {
+  const normalized = String(containerUse || "").trim();
+  if (normalized === "FormAssociationItemModel") {
+    return "DetailsItemModel";
+  }
+  return normalized;
+}
+function resolveBindingScope(containerUse) {
+  switch ((0, import_field_semantics.normalizeFieldContainerKind)(normalizeBindingContainerUse(containerUse))) {
+    case "table":
+    case "details":
+      return "display";
+    case "form":
+      return "editable";
+    case "filter-form":
+      return "filter";
+    default:
+      return null;
+  }
+}
+function isRuleAvailable(rule, enabledPackages) {
+  if (!rule.ownerPlugin || !enabledPackages) {
+    return true;
+  }
+  return enabledPackages.has(rule.ownerPlugin);
+}
+function selectPreferredDefaultRule(rules) {
+  if (!rules.length) {
+    return null;
+  }
+  return rules.find((rule) => typeof rule.when === "function") || rules[0];
+}
+const FIELD_BINDING_RULE_DEFINITIONS = [
+  {
+    scope: "display",
+    modelClassName: "DisplayPreviewFieldModel",
+    interfaces: ["url", "attachment", "attachmentURL", "m2m", "m2o", "o2o", "o2m", "oho", "obo", "mbm"],
+    ownerPlugin: FILE_MANAGER_PLUGIN,
+    isDefault: true,
+    when: ({ field, targetCollection }) => isAttachmentInterface(field) || !targetCollection || getCollectionTemplate(targetCollection) === "file"
+  },
+  {
+    scope: "editable",
+    modelClassName: "UploadFieldModel",
+    interfaces: ["attachment", "m2m", "m2o", "o2o", "o2m", "oho", "obo", "updatedBy", "createdBy", "mbm"],
+    ownerPlugin: FILE_MANAGER_PLUGIN,
+    isDefault: true,
+    order: 30,
+    when: ({ field, targetCollection }) => isAttachmentInterface(field) || !targetCollection || getCollectionTemplate(targetCollection) === "file"
+  },
+  {
+    scope: "editable",
+    modelClassName: "AttachmentURLFieldModel",
+    interfaces: ["attachmentURL"],
+    ownerPlugin: ATTACHMENT_URL_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayTextFieldModel",
+    interfaces: ["attachmentURL"],
+    ownerPlugin: ATTACHMENT_URL_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "CodeFieldModel",
+    interfaces: ["code"],
+    ownerPlugin: CODE_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayCodeFieldModel",
+    interfaces: ["code"],
+    ownerPlugin: CODE_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "filter",
+    modelClassName: "InputFieldModel",
+    interfaces: ["code"],
+    ownerPlugin: CODE_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "VditorFieldModel",
+    interfaces: ["vditor", "markdown"],
+    ownerPlugin: MARKDOWN_VDITOR_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayVditorFieldModel",
+    interfaces: ["vditor", "markdown"],
+    ownerPlugin: MARKDOWN_VDITOR_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "ChinaRegionFieldModel",
+    interfaces: ["chinaRegion"],
+    ownerPlugin: CHINA_REGION_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayChinaRegionFieldModel",
+    interfaces: ["chinaRegion"],
+    ownerPlugin: CHINA_REGION_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "SortFieldModel",
+    interfaces: ["sort"],
+    ownerPlugin: SORT_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayNumberFieldModel",
+    interfaces: ["sort"],
+    ownerPlugin: SORT_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "PointFieldModel",
+    interfaces: ["point"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "CircleFieldModel",
+    interfaces: ["circle"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "PolygonFieldModel",
+    interfaces: ["polygon"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "LineStringFieldModel",
+    interfaces: ["lineString"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayPointFieldModel",
+    interfaces: ["point"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayCircleFieldModel",
+    interfaces: ["circle"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayPolygonFieldModel",
+    interfaces: ["polygon"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayLineStringFieldModel",
+    interfaces: ["lineString"],
+    ownerPlugin: MAP_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "editable",
+    modelClassName: "FormulaFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    isDefault: true
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayCheckboxFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    isDefault: true,
+    when: ({ field }) => getFieldDataType(field) === "boolean"
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayDateTimeFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    isDefault: true,
+    when: ({ field }) => getFieldDataType(field) === "date"
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayTextFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    isDefault: true,
+    when: ({ field }) => getFieldDataType(field) === "string"
+  },
+  {
+    scope: "display",
+    modelClassName: "DisplayNumberFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    isDefault: true,
+    when: ({ field }) => ["double", "bigInt", "integer"].includes(String(getFieldDataType(field) || "").trim())
+  },
+  {
+    scope: "filter",
+    modelClassName: "InputFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    when: ({ field }) => {
+      const dataType = String(getFieldDataType(field) || "").trim();
+      return !["date", "boolean", "integer", "bigInt", "double", "decimal", "number"].includes(dataType);
+    }
+  },
+  {
+    scope: "filter",
+    modelClassName: "DateTimeFilterFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    when: ({ field }) => getFieldDataType(field) === "date"
+  },
+  {
+    scope: "filter",
+    modelClassName: "CheckboxFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    when: ({ field }) => getFieldDataType(field) === "boolean"
+  },
+  {
+    scope: "filter",
+    modelClassName: "NumberFieldModel",
+    interfaces: ["formula"],
+    ownerPlugin: FORMULA_PLUGIN,
+    when: ({ field }) => isNumericFormulaDataType(getFieldDataType(field))
+  }
+];
+const FIELD_BINDING_RULES = FIELD_BINDING_RULE_DEFINITIONS.map((rule, index) => ({
+  ...rule,
+  index
+}));
+function getRegisteredFieldUses(scope, enabledPackages) {
+  const uses = /* @__PURE__ */ new Set();
+  FIELD_BINDING_RULES.forEach((rule) => {
+    if (scope && rule.scope !== scope) {
+      return;
+    }
+    if (!isRuleAvailable(rule, enabledPackages)) {
+      return;
+    }
+    uses.add(rule.modelClassName);
+  });
+  return uses;
+}
+function resolveRegisteredFieldBinding(input) {
+  const scope = resolveBindingScope(input.containerUse);
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(input.field) || "").trim();
+  if (!scope || !fieldInterface) {
+    return null;
+  }
+  const targetCollection = resolveTargetCollection(input);
+  const candidates = FIELD_BINDING_RULES.filter((rule) => {
+    if (rule.scope !== scope) {
+      return false;
+    }
+    if (!rule.interfaces.includes(fieldInterface)) {
+      return false;
+    }
+    if (!isRuleAvailable(rule, input.enabledPackages)) {
+      return false;
+    }
+    if (!rule.when) {
+      return true;
+    }
+    return rule.when({
+      ...input,
+      targetCollection
+    });
+  }).sort((a, b) => {
+    const orderDelta = Number(a.order || 0) - Number(b.order || 0);
+    return orderDelta || a.index - b.index;
+  });
+  const defaultRule = selectPreferredDefaultRule(candidates.filter((rule) => rule.isDefault));
+  if (defaultRule) {
+    return {
+      modelClassName: defaultRule.modelClassName,
+      ownerPlugin: defaultRule.ownerPlugin,
+      isDefault: true
+    };
+  }
+  if (input.useStrictOnly) {
+    return null;
+  }
+  const fallbackRule = candidates[0];
+  if (!fallbackRule) {
+    return null;
+  }
+  return {
+    modelClassName: fallbackRule.modelClassName,
+    ownerPlugin: fallbackRule.ownerPlugin,
+    isDefault: !!fallbackRule.isDefault
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRegisteredFieldUses,
+  resolveRegisteredFieldBinding
+});

package/dist/server/flow-surfaces/field-semantics.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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.
+ */
+export declare const MULTI_VALUE_ASSOCIATION_INTERFACES: Set<string>;
+export declare function normalizeFieldContainerKind(containerUse?: string): "form" | "details" | "table" | "filter-form";
+export declare function shouldUseAssociationTitleTextDisplay(input: {
+    containerUse?: string;
+    associationPathName?: string;
+    fieldInterface?: string | null;
+}): boolean;

package/dist/server/flow-surfaces/field-semantics.js

@@ -0,0 +1,81 @@
+/**
+ * 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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var field_semantics_exports = {};
+__export(field_semantics_exports, {
+  MULTI_VALUE_ASSOCIATION_INTERFACES: () => MULTI_VALUE_ASSOCIATION_INTERFACES,
+  normalizeFieldContainerKind: () => normalizeFieldContainerKind,
+  shouldUseAssociationTitleTextDisplay: () => shouldUseAssociationTitleTextDisplay
+});
+module.exports = __toCommonJS(field_semantics_exports);
+var import_approval = require("./approval");
+const FORM_FIELD_CONTAINER_USES = /* @__PURE__ */ new Set([
+  "FormBlockModel",
+  "CreateFormModel",
+  "EditFormModel",
+  "FormGridModel",
+  "FormItemModel",
+  "AssignFormModel",
+  "AssignFormGridModel"
+]);
+const DETAILS_FIELD_CONTAINER_USES = /* @__PURE__ */ new Set([
+  "DetailsBlockModel",
+  "DetailsGridModel",
+  "DetailsItemModel",
+  "ListBlockModel",
+  "GridCardBlockModel",
+  "ListItemModel",
+  "GridCardItemModel"
+]);
+const FILTER_FIELD_CONTAINER_USES = /* @__PURE__ */ new Set(["FilterFormBlockModel", "FilterFormGridModel", "FilterFormItemModel"]);
+const TABLE_FIELD_CONTAINER_USES = /* @__PURE__ */ new Set(["TableBlockModel", "TableColumnModel"]);
+const MULTI_VALUE_ASSOCIATION_INTERFACES = /* @__PURE__ */ new Set(["m2m", "o2m", "mbm"]);
+function normalizeFieldContainerKind(containerUse) {
+  const normalized = (0, import_approval.normalizeApprovalSemanticUse)(containerUse);
+  if (FORM_FIELD_CONTAINER_USES.has(normalized)) {
+    return "form";
+  }
+  if (DETAILS_FIELD_CONTAINER_USES.has(normalized)) {
+    return "details";
+  }
+  if (FILTER_FIELD_CONTAINER_USES.has(normalized)) {
+    return "filter-form";
+  }
+  if (TABLE_FIELD_CONTAINER_USES.has(normalized)) {
+    return "table";
+  }
+  return null;
+}
+function shouldUseAssociationTitleTextDisplay(input) {
+  const containerKind = normalizeFieldContainerKind(input.containerUse);
+  return (containerKind === "table" || containerKind === "details") && !String(input.associationPathName || "").trim() && MULTI_VALUE_ASSOCIATION_INTERFACES.has(String(input.fieldInterface || "").trim());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MULTI_VALUE_ASSOCIATION_INTERFACES,
+  normalizeFieldContainerKind,
+  shouldUseAssociationTitleTextDisplay
+});

package/dist/server/flow-surfaces/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 { Plugin } from '@nocobase/server';
+import { FlowSurfacesService } from './service';
+export declare function registerFlowSurfacesResource(plugin: Plugin): FlowSurfacesService;