@nocobase/plugin-flow-engine 2.1.0-beta.15 → 2.1.0-beta.16

package/dist/server/flow-surfaces/template-display.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 { Database } from '@nocobase/database';
+import type { FlowSurfaceTemplateRow } from './template-service-utils';
+export type TemplateTranslate = (key: string, options?: Record<string, any>) => string;
+export declare function compileTemplateString(value: any, t?: TemplateTranslate): any;
+export declare function resolveFlowTemplateDisplayRow(db: Database, row: FlowSurfaceTemplateRow, options?: {
+    t?: TemplateTranslate;
+    transaction?: any;
+}): Promise<FlowSurfaceTemplateRow>;
+export declare function resolveFlowTemplateDisplayRows(db: Database, rows: FlowSurfaceTemplateRow[], options?: {
+    t?: TemplateTranslate;
+    transaction?: any;
+}): Promise<FlowSurfaceTemplateRow[]>;

package/dist/server/flow-surfaces/template-display.js

@@ -0,0 +1,289 @@
+/**
+ * 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 template_display_exports = {};
+__export(template_display_exports, {
+  compileTemplateString: () => compileTemplateString,
+  resolveFlowTemplateDisplayRow: () => resolveFlowTemplateDisplayRow,
+  resolveFlowTemplateDisplayRows: () => resolveFlowTemplateDisplayRows
+});
+module.exports = __toCommonJS(template_display_exports);
+var import_json_schema = require("@formily/json-schema");
+var import_lodash = __toESM(require("lodash"));
+var import_service_helpers = require("./service-helpers");
+var import_service_utils = require("./service-utils");
+const AUTO_GENERATED_SUFFIX = " (Auto generated)";
+const LEGACY_AUTO_POPUP_PREFIX = "Auto popup ";
+const LEGACY_AUTO_POPUP_DESCRIPTION_PREFIX = "Auto-generated popup template ";
+function getFallbackTranslate() {
+  return (key, options) => key.replace(/\{\{\s*([^}\s]+)\s*\}\}/g, (_match, name) => {
+    const value = options == null ? void 0 : options[name];
+    return import_lodash.default.isUndefined(value) || import_lodash.default.isNull(value) ? "" : String(value);
+  });
+}
+function extractTranslationKey(tokenContent) {
+  var _a;
+  const matched = tokenContent.match(/["'`]([^"'`]+)["'`]/);
+  return ((_a = matched == null ? void 0 : matched[1]) == null ? void 0 : _a.trim()) || "";
+}
+function sanitizePendingTranslationTokens(value) {
+  if (!value.includes("{{")) {
+    return value;
+  }
+  return value.replace(/\{\{\s*t\(([\s\S]*?)\)\s*\}\}/g, (_match, tokenContent) => extractTranslationKey(tokenContent));
+}
+function compileTemplateString(value, t) {
+  if (typeof value !== "string" || !value) {
+    return value;
+  }
+  try {
+    const compiled = import_json_schema.Schema.compile(value, { t: t || getFallbackTranslate() });
+    if (typeof compiled === "string") {
+      return sanitizePendingTranslationTokens(compiled).trim();
+    }
+    return compiled;
+  } catch (error) {
+    return sanitizePendingTranslationTokens(value).trim();
+  }
+}
+function inferPopupDefaultTypeFromTargetTree(node) {
+  var _a, _b, _c, _d;
+  const popupPage = (0, import_service_utils.getSingleNodeSubModel)((_a = node == null ? void 0 : node.subModels) == null ? void 0 : _a.page);
+  const popupTab = import_lodash.default.castArray(((_b = popupPage == null ? void 0 : popupPage.subModels) == null ? void 0 : _b.tabs) || [])[0];
+  const popupGrid = (0, import_service_utils.getSingleNodeSubModel)((_c = popupTab == null ? void 0 : popupTab.subModels) == null ? void 0 : _c.grid);
+  const popupBlock = (0, import_service_utils.getNodeSubModelList)((_d = popupGrid == null ? void 0 : popupGrid.subModels) == null ? void 0 : _d.items)[0];
+  if ((popupBlock == null ? void 0 : popupBlock.use) === "DetailsBlockModel") {
+    return "view";
+  }
+  if ((popupBlock == null ? void 0 : popupBlock.use) === "EditFormModel") {
+    return "edit";
+  }
+  if ((popupBlock == null ? void 0 : popupBlock.use) === "CreateFormModel") {
+    return "addNew";
+  }
+  return "generic";
+}
+function getPopupLabelKey(defaultType) {
+  switch (defaultType) {
+    case "addNew":
+      return "Popup for Add New";
+    case "edit":
+      return "Popup for Edit";
+    case "view":
+      return "Popup for Details";
+    default:
+      return "popup";
+  }
+}
+function getAutoGeneratedDisplaySuffix(t) {
+  const translate = t || getFallbackTranslate();
+  return ` (${translate("Auto generated")})`;
+}
+function isAutoGeneratedPopupTemplateName(name) {
+  return name.endsWith(AUTO_GENERATED_SUFFIX) || name.startsWith(LEGACY_AUTO_POPUP_PREFIX);
+}
+function isAutoGeneratedPopupTemplateDescription(description) {
+  return description.startsWith(LEGACY_AUTO_POPUP_DESCRIPTION_PREFIX) || description.startsWith("Automatically generated popup template for ");
+}
+function buildAutoGeneratedActionPopupMetadata(input) {
+  const translate = input.t || getFallbackTranslate();
+  const popupLabel = translate(getPopupLabelKey(input.popupType));
+  return {
+    name: `${input.collectionLabel} ${popupLabel}${getAutoGeneratedDisplaySuffix(input.t)}`,
+    description: translate(
+      'Automatically generated popup template for collection "{{collectionLabel}}" ({{popupLabel}}).',
+      {
+        collectionLabel: input.collectionLabel,
+        popupLabel
+      }
+    )
+  };
+}
+function buildAutoGeneratedAssociationPopupMetadata(input) {
+  const translate = input.t || getFallbackTranslate();
+  const popupLabel = translate(getPopupLabelKey(input.popupType));
+  return {
+    name: `${input.sourceCollectionLabel} -> ${input.associationFieldLabel} ${popupLabel}${getAutoGeneratedDisplaySuffix(input.t)}`,
+    description: translate(
+      'Automatically generated popup template for relation field "{{associationFieldLabel}}" in collection "{{sourceCollectionLabel}}", targeting "{{targetCollectionLabel}}" ({{popupLabel}}).',
+      {
+        associationFieldLabel: input.associationFieldLabel,
+        sourceCollectionLabel: input.sourceCollectionLabel,
+        targetCollectionLabel: input.targetCollectionLabel,
+        popupLabel
+      }
+    )
+  };
+}
+async function getTargetTree(db, targetUid, transaction) {
+  var _a;
+  const normalizedTargetUid = String(targetUid || "").trim();
+  if (!normalizedTargetUid) {
+    return null;
+  }
+  const repo = (_a = db.getCollection("flowModels")) == null ? void 0 : _a.repository;
+  if (!repo) {
+    return null;
+  }
+  return repo.findModelById(normalizedTargetUid, {
+    transaction,
+    includeAsyncNode: true
+  });
+}
+function getCollection(db, dataSourceKey, collectionName) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const normalizedDataSourceKey = dataSourceKey || "main";
+  const mainCollection = normalizedDataSourceKey === "main" ? (_a = db.getCollection) == null ? void 0 : _a.call(db, collectionName) : null;
+  if (mainCollection) {
+    return mainCollection;
+  }
+  const dataSourceManager = ((_b = db.app) == null ? void 0 : _b.dataSourceManager) || db.dataSourceManager;
+  const ds = ((_c = dataSourceManager == null ? void 0 : dataSourceManager.get) == null ? void 0 : _c.call(dataSourceManager, normalizedDataSourceKey)) || ((_e = (_d = dataSourceManager == null ? void 0 : dataSourceManager.dataSources) == null ? void 0 : _d.get) == null ? void 0 : _e.call(_d, normalizedDataSourceKey));
+  return ((_g = (_f = ds == null ? void 0 : ds.collectionManager) == null ? void 0 : _f.getCollection) == null ? void 0 : _g.call(_f, collectionName)) || ((_h = db.getCollection) == null ? void 0 : _h.call(db, collectionName));
+}
+function getAssociationField(collection, associationName) {
+  var _a;
+  const normalized = String(associationName || "").trim();
+  if (!normalized) {
+    return null;
+  }
+  const fieldName = normalized.split(".").slice(-1)[0];
+  return ((_a = collection == null ? void 0 : collection.getField) == null ? void 0 : _a.call(collection, fieldName)) || null;
+}
+function parseAssociationSource(associationName) {
+  const normalized = String(associationName || "").trim();
+  if (!normalized || !normalized.includes(".")) {
+    return null;
+  }
+  const parts = normalized.split(".").filter(Boolean);
+  if (parts.length < 2) {
+    return null;
+  }
+  return {
+    sourceCollectionName: parts[0],
+    associationFieldName: parts[parts.length - 1]
+  };
+}
+async function buildAutoGeneratedPopupMetadata(db, row, t, transaction) {
+  var _a, _b;
+  const targetTree = await getTargetTree(db, row.targetUid, transaction);
+  const popupType = inferPopupDefaultTypeFromTargetTree(targetTree);
+  const dataSourceKey = String(row.dataSourceKey || "main").trim() || "main";
+  const collectionName = String(row.collectionName || "").trim();
+  const associationName = String(row.associationName || "").trim();
+  const collection = getCollection(db, dataSourceKey, collectionName);
+  const collectionLabel = String(
+    compileTemplateString((0, import_service_helpers.getCollectionTitle)(collection) || collectionName, t) || ""
+  ).trim();
+  if (associationName) {
+    const associationSource = parseAssociationSource(associationName);
+    const sourceCollectionName = (associationSource == null ? void 0 : associationSource.sourceCollectionName) || collectionName;
+    const sourceCollection = getCollection(db, dataSourceKey, sourceCollectionName) || collection;
+    const associationField = getAssociationField(sourceCollection, associationName) || ((_a = sourceCollection == null ? void 0 : sourceCollection.getField) == null ? void 0 : _a.call(sourceCollection, (associationSource == null ? void 0 : associationSource.associationFieldName) || ""));
+    const targetCollectionName = String((associationField == null ? void 0 : associationField.target) || ((_b = associationField == null ? void 0 : associationField.options) == null ? void 0 : _b.target) || collectionName || "").trim() || collectionName;
+    const targetCollection = getCollection(db, dataSourceKey, targetCollectionName) || collection;
+    const sourceCollectionLabel = String(
+      compileTemplateString(
+        (0, import_service_helpers.getCollectionTitle)(sourceCollection) || (0, import_service_helpers.getCollectionName)(sourceCollection) || sourceCollectionName,
+        t
+      ) || ""
+    ).trim();
+    const associationFieldLabel = String(
+      compileTemplateString(
+        (0, import_service_helpers.getFieldTitle)(associationField) || (0, import_service_helpers.getFieldName)(associationField) || (associationSource == null ? void 0 : associationSource.associationFieldName) || "",
+        t
+      ) || ""
+    ).trim();
+    const targetCollectionLabel = String(
+      compileTemplateString(
+        (0, import_service_helpers.getCollectionTitle)(targetCollection) || (0, import_service_helpers.getCollectionName)(targetCollection) || targetCollectionName,
+        t
+      ) || ""
+    ).trim();
+    if (sourceCollectionLabel && associationFieldLabel && targetCollectionLabel) {
+      return buildAutoGeneratedAssociationPopupMetadata({
+        popupType,
+        sourceCollectionLabel,
+        associationFieldLabel,
+        targetCollectionLabel,
+        t
+      });
+    }
+  }
+  if (collectionLabel) {
+    return buildAutoGeneratedActionPopupMetadata({
+      popupType,
+      collectionLabel,
+      t
+    });
+  }
+  return null;
+}
+async function resolveFlowTemplateDisplayRow(db, row, options = {}) {
+  const plainRow = typeof (row == null ? void 0 : row.toJSON) === "function" ? row.toJSON() : row;
+  if (!plainRow) {
+    return plainRow;
+  }
+  const t = options.t || getFallbackTranslate();
+  const nextRow = {
+    ...plainRow,
+    name: compileTemplateString(plainRow.name, t),
+    description: compileTemplateString(plainRow.description, t)
+  };
+  const hasAutoGeneratedName = isAutoGeneratedPopupTemplateName(String(nextRow.name || "").trim());
+  const hasAutoGeneratedDescription = isAutoGeneratedPopupTemplateDescription(String(nextRow.description || "").trim());
+  if (String(nextRow.type || "").trim() !== "popup" || !hasAutoGeneratedName && !hasAutoGeneratedDescription) {
+    return nextRow;
+  }
+  const rewritten = await buildAutoGeneratedPopupMetadata(db, nextRow, t, options.transaction);
+  if (!rewritten) {
+    return nextRow;
+  }
+  return {
+    ...nextRow,
+    name: hasAutoGeneratedName ? rewritten.name : nextRow.name,
+    description: hasAutoGeneratedDescription ? rewritten.description : nextRow.description
+  };
+}
+async function resolveFlowTemplateDisplayRows(db, rows, options = {}) {
+  return Promise.all(rows.map((row) => resolveFlowTemplateDisplayRow(db, row, options)));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileTemplateString,
+  resolveFlowTemplateDisplayRow,
+  resolveFlowTemplateDisplayRows
+});

package/dist/server/flow-surfaces/template-service-utils.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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 _ from 'lodash';
+import type { FlowSurfaceWriteTarget } from './types';
+export type FlowSurfaceTemplateRow = {
+    uid: string;
+    name?: string;
+    description?: string;
+    targetUid?: string;
+    useModel?: string;
+    type?: string;
+    dataSourceKey?: string;
+    collectionName?: string;
+    associationName?: string;
+    filterByTk?: string;
+    sourceId?: string;
+    usageCount?: number;
+    available?: boolean;
+    disabledReason?: string;
+};
+export type FlowSurfaceTemplateListValues = {
+    search?: string;
+    filter?: Record<string, any>;
+    sort?: string | string[];
+    page?: number;
+    pageSize?: number;
+    target?: FlowSurfaceWriteTarget;
+    type?: 'block' | 'popup';
+    usage?: 'block' | 'fields';
+    actionType?: string;
+    actionScope?: 'block' | 'record';
+};
+export type FlowSurfaceTemplateListPopupActionContext = {
+    hasCurrentRecord?: boolean;
+};
+export declare const FLOW_TEMPLATE_SUPPORTED_TYPES: Set<string>;
+export declare const FLOW_TEMPLATE_SUPPORTED_MODES: Set<string>;
+export declare const FLOW_TEMPLATE_BLOCK_USAGES: Set<string>;
+export declare const FLOW_TEMPLATE_UNSUPPORTED_BLOCK_TEMPLATE_SOURCE_USES: Set<string>;
+export declare const POPUP_HOST_STEP_PARAM_PATHS: readonly [readonly ["popupSettings", "openView"], readonly ["selectExitRecordSettings", "openView"], readonly ["openSelectRecordView", "openView"], readonly ["openAddRecordView", "openView"]];
+export declare function normalizeTemplateUidValue(actionName: string, values: Record<string, any>): string;
+export declare function normalizeRequiredTemplateString(actionName: string, value: any, field: string): string;
+export declare function normalizeTemplateSaveMode(actionName: string, value: any): "duplicate" | "convert";
+export declare function buildTemplateListFilter(existingFilter: any, search: any, requestedType?: 'block' | 'popup'): any;
+export declare function findFlowTemplateOpenViewStep(node: any): {
+    flowKey: "popupSettings" | "selectExitRecordSettings" | "openSelectRecordView" | "openAddRecordView";
+    stepKey: "openView";
+    openView: any;
+};
+export declare function buildFlowTemplateReferenceBlockStepParams(template: FlowSurfaceTemplateRow, templateTargetUid: string, resourceInit?: Record<string, any>): _.Dictionary<any>;
+export declare function collectFlowTemplateUsageMapFromModelOptions(modelUid: string, options: any, carry?: Map<string, Set<string>>): Map<string, Set<string>>;
+export declare function collectFlowTemplateModelUids(node: any, carry?: Set<string>): Set<string>;
+export declare function replaceFlowModelTreeUids(node: any, uidMap: Record<string, string>): any;
+export declare function stripTemplateInternalOpenViewFields(openView: any): any;
+export declare function stripTemplateInternalReferenceSettings(node: any): void;
+export declare function findFieldsTemplateReferenceGrid(node: any): import("./types").FlowSurfaceNodeSpec;

package/dist/server/flow-surfaces/template-service-utils.js

@@ -0,0 +1,281 @@
+/**
+ * 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 template_service_utils_exports = {};
+__export(template_service_utils_exports, {
+  FLOW_TEMPLATE_BLOCK_USAGES: () => FLOW_TEMPLATE_BLOCK_USAGES,
+  FLOW_TEMPLATE_SUPPORTED_MODES: () => FLOW_TEMPLATE_SUPPORTED_MODES,
+  FLOW_TEMPLATE_SUPPORTED_TYPES: () => FLOW_TEMPLATE_SUPPORTED_TYPES,
+  FLOW_TEMPLATE_UNSUPPORTED_BLOCK_TEMPLATE_SOURCE_USES: () => FLOW_TEMPLATE_UNSUPPORTED_BLOCK_TEMPLATE_SOURCE_USES,
+  POPUP_HOST_STEP_PARAM_PATHS: () => POPUP_HOST_STEP_PARAM_PATHS,
+  buildFlowTemplateReferenceBlockStepParams: () => buildFlowTemplateReferenceBlockStepParams,
+  buildTemplateListFilter: () => buildTemplateListFilter,
+  collectFlowTemplateModelUids: () => collectFlowTemplateModelUids,
+  collectFlowTemplateUsageMapFromModelOptions: () => collectFlowTemplateUsageMapFromModelOptions,
+  findFieldsTemplateReferenceGrid: () => findFieldsTemplateReferenceGrid,
+  findFlowTemplateOpenViewStep: () => findFlowTemplateOpenViewStep,
+  normalizeRequiredTemplateString: () => normalizeRequiredTemplateString,
+  normalizeTemplateSaveMode: () => normalizeTemplateSaveMode,
+  normalizeTemplateUidValue: () => normalizeTemplateUidValue,
+  replaceFlowModelTreeUids: () => replaceFlowModelTreeUids,
+  stripTemplateInternalOpenViewFields: () => stripTemplateInternalOpenViewFields,
+  stripTemplateInternalReferenceSettings: () => stripTemplateInternalReferenceSettings
+});
+module.exports = __toCommonJS(template_service_utils_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_service_helpers = require("./service-helpers");
+var import_service_utils = require("./service-utils");
+var import_errors = require("./errors");
+const FLOW_TEMPLATE_SUPPORTED_TYPES = /* @__PURE__ */ new Set(["block", "popup"]);
+const FLOW_TEMPLATE_SUPPORTED_MODES = /* @__PURE__ */ new Set(["reference", "copy"]);
+const FLOW_TEMPLATE_BLOCK_USAGES = /* @__PURE__ */ new Set(["block", "fields"]);
+const FLOW_TEMPLATE_UNSUPPORTED_BLOCK_TEMPLATE_SOURCE_USES = /* @__PURE__ */ new Set([
+  "ApplyTaskCardDetailsModel",
+  "ApprovalTaskCardDetailsModel"
+]);
+const POPUP_HOST_STEP_PARAM_PATHS = [
+  ["popupSettings", "openView"],
+  ["selectExitRecordSettings", "openView"],
+  ["openSelectRecordView", "openView"],
+  ["openAddRecordView", "openView"]
+];
+function normalizeTemplateUidValue(actionName, values) {
+  const templateUid = String((values == null ? void 0 : values.filterByTk) || (values == null ? void 0 : values.uid) || "").trim();
+  if (!templateUid) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} template uid is required`, "FLOW_SURFACE_TEMPLATE_UID_REQUIRED");
+  }
+  return templateUid;
+}
+function normalizeRequiredTemplateString(actionName, value, field) {
+  const normalized = String(value || "").trim();
+  if (!normalized) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${field} is required`, "FLOW_SURFACE_TEMPLATE_REQUIRED_FIELD");
+  }
+  return normalized;
+}
+function normalizeTemplateSaveMode(actionName, value) {
+  const normalized = String(value || "duplicate").trim() || "duplicate";
+  if (normalized !== "duplicate" && normalized !== "convert") {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${actionName} saveMode only supports 'duplicate' or 'convert'`,
+      "FLOW_SURFACE_TEMPLATE_SAVE_MODE_UNSUPPORTED"
+    );
+  }
+  return normalized;
+}
+function buildTemplateListFilter(existingFilter, search, requestedType) {
+  const typeFilter = requestedType ? { type: requestedType } : void 0;
+  return (0, import_service_helpers.buildFlowTemplateSearchFilter)(
+    existingFilter && typeFilter ? { $and: [existingFilter, typeFilter] } : existingFilter || typeFilter,
+    search
+  );
+}
+function findFlowTemplateOpenViewStep(node) {
+  for (const [flowKey, stepKey] of POPUP_HOST_STEP_PARAM_PATHS) {
+    const openView = import_lodash.default.get(node, ["stepParams", flowKey, stepKey]);
+    if (import_lodash.default.isPlainObject(openView)) {
+      return {
+        flowKey,
+        stepKey,
+        openView
+      };
+    }
+  }
+  return null;
+}
+function buildFlowTemplateReferenceBlockStepParams(template, templateTargetUid, resourceInit) {
+  const normalizedResourceInit = (0, import_service_utils.buildDefinedPayload)(resourceInit || {});
+  return (0, import_service_utils.buildDefinedPayload)({
+    referenceSettings: {
+      target: {
+        targetUid: templateTargetUid,
+        mode: "reference"
+      },
+      useTemplate: {
+        templateUid: template.uid,
+        templateName: template.name,
+        templateDescription: template.description,
+        targetUid: templateTargetUid,
+        mode: "reference"
+      }
+    },
+    ...Object.keys(normalizedResourceInit).length ? {
+      resourceSettings: {
+        init: normalizedResourceInit
+      }
+    } : {}
+  });
+}
+function collectFlowTemplateUsageMapFromModelOptions(modelUid, options, carry = /* @__PURE__ */ new Map()) {
+  const normalizedModelUid = String(modelUid || "").trim();
+  if (!normalizedModelUid) {
+    return carry;
+  }
+  const addUsage = (templateUid) => {
+    var _a;
+    const normalizedTemplateUid = String(templateUid || "").trim();
+    if (!normalizedTemplateUid) {
+      return;
+    }
+    if (!carry.has(normalizedModelUid)) {
+      carry.set(normalizedModelUid, /* @__PURE__ */ new Set());
+    }
+    (_a = carry.get(normalizedModelUid)) == null ? void 0 : _a.add(normalizedTemplateUid);
+  };
+  const normalizedOptions = import_lodash.default.isPlainObject(options) || Array.isArray(options) ? options : typeof options === "string" ? JSON.parse(options) : {};
+  const useTemplate = import_lodash.default.get(normalizedOptions, ["stepParams", "referenceSettings", "useTemplate"]);
+  const useTemplateUid = String((useTemplate == null ? void 0 : useTemplate.templateUid) || "").trim();
+  const useTemplateMode = String((useTemplate == null ? void 0 : useTemplate.mode) || "reference").trim() || "reference";
+  if (useTemplateUid && useTemplateMode !== "copy") {
+    addUsage(useTemplateUid);
+  }
+  const popupGroups = [
+    import_lodash.default.get(normalizedOptions, ["stepParams", "popupSettings"]),
+    import_lodash.default.get(normalizedOptions, ["stepParams", "selectExitRecordSettings"])
+  ];
+  for (const group of popupGroups) {
+    if (!group || typeof group !== "object") {
+      continue;
+    }
+    for (const value of Object.values(group)) {
+      const popupTemplateUid = String((value == null ? void 0 : value.popupTemplateUid) || "").trim();
+      const popupTemplateMode = String((value == null ? void 0 : value.popupTemplateMode) || "reference").trim() || "reference";
+      if (popupTemplateUid && popupTemplateMode !== "copy") {
+        addUsage(popupTemplateUid);
+      }
+    }
+  }
+  return carry;
+}
+function collectFlowTemplateModelUids(node, carry = /* @__PURE__ */ new Set()) {
+  if (!(node == null ? void 0 : node.uid)) {
+    return carry;
+  }
+  carry.add(String(node.uid));
+  for (const child of Object.values(node.subModels || {})) {
+    for (const item of import_lodash.default.castArray(child)) {
+      collectFlowTemplateModelUids(item, carry);
+    }
+  }
+  return carry;
+}
+function replaceFlowModelTreeUids(node, uidMap) {
+  const replaceInPlace = (value) => {
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i += 1) {
+        value[i] = replaceInPlace(value[i]);
+      }
+      return value;
+    }
+    if (value && typeof value === "object") {
+      for (const key of Object.keys(value)) {
+        value[key] = replaceInPlace(value[key]);
+      }
+      return value;
+    }
+    return typeof value === "string" && uidMap[value] ? uidMap[value] : value;
+  };
+  const walk = (current) => {
+    if (!current || typeof current !== "object") {
+      return current;
+    }
+    if (typeof current.uid === "string" && uidMap[current.uid]) {
+      current.uid = uidMap[current.uid];
+    }
+    if (typeof current.parent === "string" && uidMap[current.parent]) {
+      current.parent = uidMap[current.parent];
+    }
+    if (typeof current.parentId === "string" && uidMap[current.parentId]) {
+      current.parentId = uidMap[current.parentId];
+    }
+    if (current.stepParams) {
+      current.stepParams = replaceInPlace(current.stepParams);
+    }
+    Object.values(current.subModels || {}).forEach((child) => {
+      import_lodash.default.castArray(child).forEach((item) => walk(item));
+    });
+    return current;
+  };
+  return walk(import_lodash.default.cloneDeep(node));
+}
+function stripTemplateInternalOpenViewFields(openView) {
+  if (!import_lodash.default.isPlainObject(openView)) {
+    return openView;
+  }
+  const hasTemplateState = !!String(openView.popupTemplateUid || "").trim() || !!openView.popupTemplateContext || !!String(openView.popupTemplateMode || "").trim();
+  return import_lodash.default.omit(openView, [
+    "popupTemplateUid",
+    "popupTemplateMode",
+    "popupTemplateContext",
+    "popupTemplateHasFilterByTk",
+    "popupTemplateHasSourceId",
+    ...hasTemplateState ? ["uid"] : []
+  ]);
+}
+function stripTemplateInternalReferenceSettings(node) {
+  var _a;
+  if (!import_lodash.default.isPlainObject((_a = node == null ? void 0 : node.stepParams) == null ? void 0 : _a.referenceSettings)) {
+    return;
+  }
+  delete node.stepParams.referenceSettings;
+  if (import_lodash.default.isPlainObject(node.stepParams) && !Object.keys(node.stepParams).length) {
+    delete node.stepParams;
+  }
+}
+function findFieldsTemplateReferenceGrid(node) {
+  var _a;
+  return (0, import_service_utils.getSingleNodeSubModel)((_a = node == null ? void 0 : node.subModels) == null ? void 0 : _a.grid);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FLOW_TEMPLATE_BLOCK_USAGES,
+  FLOW_TEMPLATE_SUPPORTED_MODES,
+  FLOW_TEMPLATE_SUPPORTED_TYPES,
+  FLOW_TEMPLATE_UNSUPPORTED_BLOCK_TEMPLATE_SOURCE_USES,
+  POPUP_HOST_STEP_PARAM_PATHS,
+  buildFlowTemplateReferenceBlockStepParams,
+  buildTemplateListFilter,
+  collectFlowTemplateModelUids,
+  collectFlowTemplateUsageMapFromModelOptions,
+  findFieldsTemplateReferenceGrid,
+  findFlowTemplateOpenViewStep,
+  normalizeRequiredTemplateString,
+  normalizeTemplateSaveMode,
+  normalizeTemplateUidValue,
+  replaceFlowModelTreeUids,
+  stripTemplateInternalOpenViewFields,
+  stripTemplateInternalReferenceSettings
+});