@nocobase/plugin-flow-engine 2.1.0-beta.2 → 2.1.0-beta.21

package/dist/server/flow-surfaces/default-action-popup.js

@@ -0,0 +1,322 @@
+/**
+ * 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 default_action_popup_exports = {};
+__export(default_action_popup_exports, {
+  FLOW_SURFACE_DEFAULT_ACTION_POPUP_TYPES: () => FLOW_SURFACE_DEFAULT_ACTION_POPUP_TYPES,
+  FLOW_SURFACE_DEFAULT_ACTION_POPUP_USES: () => FLOW_SURFACE_DEFAULT_ACTION_POPUP_USES,
+  buildFlowSurfaceDefaultActionPopupBlocks: () => buildFlowSurfaceDefaultActionPopupBlocks,
+  getFlowSurfaceDefaultActionPopupConfigByUse: () => getFlowSurfaceDefaultActionPopupConfigByUse,
+  hasFlowSurfaceInlinePopupBlocks: () => hasFlowSurfaceInlinePopupBlocks,
+  hasFlowSurfaceInlinePopupTemplate: () => hasFlowSurfaceInlinePopupTemplate,
+  isFlowSurfaceDefaultActionPopupType: () => isFlowSurfaceDefaultActionPopupType,
+  isFlowSurfaceDefaultActionPopupUse: () => isFlowSurfaceDefaultActionPopupUse,
+  pickFlowSurfaceDefaultActionPopupFieldGroups: () => pickFlowSurfaceDefaultActionPopupFieldGroups,
+  pickFlowSurfaceDefaultActionPopupFieldPaths: () => pickFlowSurfaceDefaultActionPopupFieldPaths,
+  resolveFlowSurfaceDefaultActionPopupTabTitle: () => resolveFlowSurfaceDefaultActionPopupTabTitle
+});
+module.exports = __toCommonJS(default_action_popup_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_association_interfaces = require("./association-interfaces");
+var import_service_helpers = require("./service-helpers");
+const DEFAULT_ACTION_POPUP_SYSTEM_FIELD_NAMES = /* @__PURE__ */ new Set(["id", "createdBy", "createdById", "updatedBy", "updatedById"]);
+const DEFAULT_ACTION_POPUP_SYSTEM_FIELD_INTERFACES = /* @__PURE__ */ new Set([
+  "id",
+  "snowflakeId",
+  "createdBy",
+  "createdById",
+  "updatedBy",
+  "updatedById"
+]);
+const DEFAULT_ACTION_POPUP_AUDIT_TIMESTAMP_FIELD_NAMES = /* @__PURE__ */ new Set(["createdAt", "updatedAt"]);
+const DEFAULT_ACTION_POPUP_AUDIT_TIMESTAMP_FIELD_INTERFACES = /* @__PURE__ */ new Set(["createdAt", "updatedAt"]);
+const FLOW_SURFACE_DEFAULT_ACTION_POPUP_CONFIGS = [
+  {
+    type: "addNew",
+    use: "AddNewActionModel",
+    defaultButtonTitle: '{{t("Add new")}}',
+    defaultPopupTabTitle: '{{t("Add new")}}',
+    blockKey: "defaultCreateForm",
+    blockType: "createForm",
+    blockUse: "CreateFormModel",
+    resourceBinding: "currentCollection",
+    blockSettings: {
+      layout: "vertical",
+      colon: false,
+      assignRules: []
+    },
+    submitAction: {
+      key: "defaultSubmit",
+      type: "submit",
+      settings: {
+        title: '{{t("Submit")}}',
+        type: "primary",
+        confirm: false
+      }
+    }
+  },
+  {
+    type: "view",
+    use: "ViewActionModel",
+    defaultButtonTitle: '{{t("View")}}',
+    defaultPopupTabTitle: '{{t("Details")}}',
+    blockKey: "defaultDetails",
+    blockType: "details",
+    blockUse: "DetailsBlockModel",
+    resourceBinding: "currentRecord",
+    blockSettings: {
+      layout: "vertical",
+      colon: true,
+      dataScope: {
+        logic: "$and",
+        items: []
+      },
+      linkageRules: []
+    }
+  },
+  {
+    type: "edit",
+    use: "EditActionModel",
+    defaultButtonTitle: '{{t("Edit")}}',
+    defaultPopupTabTitle: '{{t("Edit")}}',
+    blockKey: "defaultEditForm",
+    blockType: "editForm",
+    blockUse: "EditFormModel",
+    resourceBinding: "currentRecord",
+    blockSettings: {
+      layout: "vertical",
+      colon: false,
+      assignRules: [],
+      dataScope: {
+        logic: "$and",
+        items: []
+      }
+    },
+    submitAction: {
+      key: "defaultSubmit",
+      type: "submit",
+      settings: {
+        title: '{{t("Submit")}}',
+        type: "primary",
+        confirm: false
+      }
+    }
+  }
+];
+const FLOW_SURFACE_DEFAULT_ACTION_POPUP_TYPES = new Set(
+  FLOW_SURFACE_DEFAULT_ACTION_POPUP_CONFIGS.map((item) => item.type)
+);
+const FLOW_SURFACE_DEFAULT_ACTION_POPUP_USES = new Set(
+  FLOW_SURFACE_DEFAULT_ACTION_POPUP_CONFIGS.map((item) => item.use)
+);
+const FLOW_SURFACE_DEFAULT_ACTION_POPUP_CONFIG_BY_USE = FLOW_SURFACE_DEFAULT_ACTION_POPUP_CONFIGS.reduce(
+  (result, item) => {
+    result[item.use] = item;
+    return result;
+  },
+  {}
+);
+const FLOW_SURFACE_DEFAULT_ACTION_POPUP_LEGACY_BUTTON_TITLES = {
+  AddNewActionModel: "Add new",
+  ViewActionModel: "View",
+  EditActionModel: "Edit"
+};
+function isFlowSurfaceDefaultActionPopupType(type) {
+  return FLOW_SURFACE_DEFAULT_ACTION_POPUP_TYPES.has(String(type || "").trim());
+}
+function isFlowSurfaceDefaultActionPopupUse(use) {
+  return FLOW_SURFACE_DEFAULT_ACTION_POPUP_USES.has(String(use || "").trim());
+}
+function getFlowSurfaceDefaultActionPopupConfigByUse(use) {
+  const normalizedUse = String(use || "").trim();
+  if (!isFlowSurfaceDefaultActionPopupUse(normalizedUse)) {
+    return void 0;
+  }
+  return FLOW_SURFACE_DEFAULT_ACTION_POPUP_CONFIG_BY_USE[normalizedUse];
+}
+function resolveFlowSurfaceDefaultActionPopupTabTitle(use, currentTitle) {
+  const actionConfig = getFlowSurfaceDefaultActionPopupConfigByUse(use);
+  if (!actionConfig) {
+    return void 0;
+  }
+  const normalizedTitle = String(currentTitle || "").trim();
+  const legacyDefaultButtonTitle = FLOW_SURFACE_DEFAULT_ACTION_POPUP_LEGACY_BUTTON_TITLES[actionConfig.use];
+  if (normalizedTitle && normalizedTitle !== actionConfig.defaultButtonTitle && normalizedTitle !== legacyDefaultButtonTitle) {
+    return normalizedTitle;
+  }
+  return actionConfig.defaultPopupTabTitle;
+}
+function isFlowSurfaceDefaultActionPopupSystemField(field) {
+  var _a, _b;
+  const fieldName = String((0, import_service_helpers.getFieldName)(field) || "").trim();
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim();
+  return DEFAULT_ACTION_POPUP_SYSTEM_FIELD_NAMES.has(fieldName) || DEFAULT_ACTION_POPUP_SYSTEM_FIELD_INTERFACES.has(fieldInterface) || !!(field == null ? void 0 : field.primaryKey) || !!((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.primaryKey) || !!(field == null ? void 0 : field.autoIncrement) || !!((_b = field == null ? void 0 : field.options) == null ? void 0 : _b.autoIncrement);
+}
+function isFlowSurfaceDefaultActionPopupTechnicalIdField(field) {
+  var _a, _b;
+  const fieldName = String((0, import_service_helpers.getFieldName)(field) || "").trim();
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim();
+  return fieldName === "id" || fieldInterface === "id" || fieldInterface === "snowflakeId" || !!(field == null ? void 0 : field.primaryKey) || !!((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.primaryKey) || !!(field == null ? void 0 : field.autoIncrement) || !!((_b = field == null ? void 0 : field.options) == null ? void 0 : _b.autoIncrement);
+}
+function isFlowSurfaceDefaultActionPopupAuditTimestampField(field) {
+  const fieldName = String((0, import_service_helpers.getFieldName)(field) || "").trim();
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim();
+  return DEFAULT_ACTION_POPUP_AUDIT_TIMESTAMP_FIELD_NAMES.has(fieldName) || DEFAULT_ACTION_POPUP_AUDIT_TIMESTAMP_FIELD_INTERFACES.has(fieldInterface);
+}
+function isFlowSurfaceDefaultActionPopupMultiValueAssociationField(field) {
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim();
+  return import_association_interfaces.MULTI_VALUE_ASSOCIATION_INTERFACES.has(fieldInterface);
+}
+function isFlowSurfaceDefaultActionPopupAssociationField(field) {
+  const fieldType = String((0, import_service_helpers.getFieldType)(field) || "").trim();
+  return fieldType === "belongsTo" || fieldType === "hasOne" || fieldType === "hasMany" || fieldType === "belongsToMany";
+}
+function collectFlowSurfaceDefaultActionPopupAssociationForeignKeys(candidates) {
+  return new Set(
+    candidates.map((candidate) => candidate == null ? void 0 : candidate.field).filter((field) => (0, import_service_helpers.getFieldType)(field) === "belongsTo").map((field) => {
+      var _a;
+      return String((field == null ? void 0 : field.foreignKey) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.foreignKey) || "").trim();
+    }).filter(Boolean)
+  );
+}
+function isFlowSurfaceDefaultActionPopupAssociationForeignKeyField(field, associationForeignKeys) {
+  const fieldName = String((0, import_service_helpers.getFieldName)(field) || "").trim();
+  return !!fieldName && associationForeignKeys.has(fieldName);
+}
+function pickFlowSurfaceDefaultActionPopupFieldPaths(candidates, options = {}) {
+  return filterFlowSurfaceDefaultActionPopupFieldCandidates(candidates, options).map((candidate) => String((candidate == null ? void 0 : candidate.fieldPath) || "").trim()).filter(Boolean);
+}
+function filterFlowSurfaceDefaultActionPopupFieldCandidates(candidates, options = {}) {
+  const associationForeignKeys = collectFlowSurfaceDefaultActionPopupAssociationForeignKeys(candidates);
+  const preferredCandidates = candidates.filter(
+    (candidate) => !isFlowSurfaceDefaultActionPopupSystemField(candidate.field) && (!options.excludeAuditTimestampFields || !isFlowSurfaceDefaultActionPopupAuditTimestampField(candidate.field)) && (!options.excludeAssociationFields || !isFlowSurfaceDefaultActionPopupAssociationField(candidate.field)) && !isFlowSurfaceDefaultActionPopupMultiValueAssociationField(candidate.field) && !isFlowSurfaceDefaultActionPopupAssociationForeignKeyField(candidate.field, associationForeignKeys)
+  );
+  const fallbackCandidates = candidates.filter(
+    (candidate) => !isFlowSurfaceDefaultActionPopupTechnicalIdField(candidate.field) && (!options.excludeAuditTimestampFields || !isFlowSurfaceDefaultActionPopupAuditTimestampField(candidate.field)) && (!options.excludeAssociationFields || !isFlowSurfaceDefaultActionPopupAssociationField(candidate.field)) && !isFlowSurfaceDefaultActionPopupMultiValueAssociationField(candidate.field) && !isFlowSurfaceDefaultActionPopupAssociationForeignKeyField(candidate.field, associationForeignKeys)
+  );
+  const baseCandidates = preferredCandidates.length ? preferredCandidates : fallbackCandidates;
+  return baseCandidates.filter((candidate) => String((candidate == null ? void 0 : candidate.fieldPath) || "").trim());
+}
+function pickFlowSurfaceDefaultActionPopupFieldGroups(candidates, fieldGroups, options = {}) {
+  const allowedFieldPaths = new Set(
+    filterFlowSurfaceDefaultActionPopupFieldCandidates(candidates, options).map(
+      (candidate) => String((candidate == null ? void 0 : candidate.fieldPath) || "").trim()
+    )
+  );
+  const usedFieldPaths = /* @__PURE__ */ new Set();
+  return import_lodash.default.castArray(fieldGroups || []).flatMap((group) => {
+    const title = String((group == null ? void 0 : group.title) || "").trim();
+    if (!title) {
+      return [];
+    }
+    const fields = import_lodash.default.castArray((group == null ? void 0 : group.fields) || []).map((field) => String(field || "").trim()).filter((field) => {
+      if (!field || !allowedFieldPaths.has(field) || usedFieldPaths.has(field)) {
+        return false;
+      }
+      usedFieldPaths.add(field);
+      return true;
+    });
+    if (!fields.length) {
+      return [];
+    }
+    return [
+      import_lodash.default.pickBy(
+        {
+          key: String((group == null ? void 0 : group.key) || "").trim() || void 0,
+          title,
+          fields
+        },
+        (value) => !import_lodash.default.isUndefined(value)
+      )
+    ];
+  });
+}
+function normalizeDefaultActionPopupFieldsInput(input) {
+  if (Array.isArray(input)) {
+    return {
+      fieldPaths: input,
+      fieldGroups: []
+    };
+  }
+  return {
+    fieldPaths: import_lodash.default.castArray((input == null ? void 0 : input.fieldPaths) || []).map((field) => String(field || "").trim()).filter(Boolean),
+    fieldGroups: import_lodash.default.castArray((input == null ? void 0 : input.fieldGroups) || []).filter((group) => import_lodash.default.isPlainObject(group))
+  };
+}
+function buildFlowSurfaceDefaultActionPopupBlocks(use, fieldsInput) {
+  const actionConfig = getFlowSurfaceDefaultActionPopupConfigByUse(use);
+  if (!actionConfig) {
+    return [];
+  }
+  const { fieldPaths, fieldGroups } = normalizeDefaultActionPopupFieldsInput(fieldsInput);
+  const hasFieldGroups = !!fieldGroups.length;
+  return [
+    import_lodash.default.pickBy(
+      {
+        key: actionConfig.blockKey,
+        type: actionConfig.blockType,
+        resource: {
+          binding: actionConfig.resourceBinding
+        },
+        settings: import_lodash.default.cloneDeep(actionConfig.blockSettings),
+        fields: hasFieldGroups ? void 0 : fieldPaths,
+        fieldGroups: hasFieldGroups ? fieldGroups : void 0,
+        actions: actionConfig.submitAction ? [import_lodash.default.cloneDeep(actionConfig.submitAction)] : void 0
+      },
+      (value) => !import_lodash.default.isUndefined(value)
+    )
+  ];
+}
+function hasFlowSurfaceInlinePopupTemplate(popup) {
+  return typeof popup !== "undefined" && typeof (popup == null ? void 0 : popup.template) !== "undefined";
+}
+function hasFlowSurfaceInlinePopupBlocks(popup) {
+  return Array.isArray(popup == null ? void 0 : popup.blocks) && popup.blocks.length > 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FLOW_SURFACE_DEFAULT_ACTION_POPUP_TYPES,
+  FLOW_SURFACE_DEFAULT_ACTION_POPUP_USES,
+  buildFlowSurfaceDefaultActionPopupBlocks,
+  getFlowSurfaceDefaultActionPopupConfigByUse,
+  hasFlowSurfaceInlinePopupBlocks,
+  hasFlowSurfaceInlinePopupTemplate,
+  isFlowSurfaceDefaultActionPopupType,
+  isFlowSurfaceDefaultActionPopupUse,
+  pickFlowSurfaceDefaultActionPopupFieldGroups,
+  pickFlowSurfaceDefaultActionPopupFieldPaths,
+  resolveFlowSurfaceDefaultActionPopupTabTitle
+});

package/dist/server/flow-surfaces/default-block-actions.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.
+ */
+export declare const FLOW_SURFACE_INTERNAL_AUTO_SAVE_DEFAULT_POPUP_TEMPLATE_KEY = "__flowSurfaceAutoSaveDefaultPopupTemplate";
+export type FlowSurfaceDefaultBlockActionScope = 'actions' | 'recordActions';
+export type FlowSurfaceDefaultBlockActionDescriptor = {
+    type: string;
+    scope: FlowSurfaceDefaultBlockActionScope;
+    popup?: Record<string, any>;
+};
+export declare function getFlowSurfaceDefaultBlockActions(input: {
+    blockType?: string;
+    template?: unknown;
+}): FlowSurfaceDefaultBlockActionDescriptor[];
+export declare function mergeFlowSurfaceDefaultBlockActions<T extends {
+    type?: string;
+    popup?: Record<string, any>;
+}>(input: {
+    blockType?: string;
+    template?: unknown;
+    actions?: T[];
+    recordActions?: T[];
+    createAction: (descriptor: FlowSurfaceDefaultBlockActionDescriptor) => T;
+}): {
+    actions: T[];
+    recordActions: T[];
+};

package/dist/server/flow-surfaces/default-block-actions.js

@@ -0,0 +1,209 @@
+/**
+ * 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 default_block_actions_exports = {};
+__export(default_block_actions_exports, {
+  FLOW_SURFACE_INTERNAL_AUTO_SAVE_DEFAULT_POPUP_TEMPLATE_KEY: () => FLOW_SURFACE_INTERNAL_AUTO_SAVE_DEFAULT_POPUP_TEMPLATE_KEY,
+  getFlowSurfaceDefaultBlockActions: () => getFlowSurfaceDefaultBlockActions,
+  mergeFlowSurfaceDefaultBlockActions: () => mergeFlowSurfaceDefaultBlockActions
+});
+module.exports = __toCommonJS(default_block_actions_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_defaults = require("./blueprint/defaults");
+const FLOW_SURFACE_INTERNAL_AUTO_SAVE_DEFAULT_POPUP_TEMPLATE_KEY = "__flowSurfaceAutoSaveDefaultPopupTemplate";
+const FLOW_SURFACE_DEFAULT_BLOCK_ACTIONS = {
+  table: [
+    { type: "filter", scope: "actions" },
+    {
+      type: "addNew",
+      scope: "actions",
+      popup: {
+        tryTemplate: true,
+        [FLOW_SURFACE_INTERNAL_AUTO_SAVE_DEFAULT_POPUP_TEMPLATE_KEY]: true
+      }
+    },
+    { type: "refresh", scope: "actions" }
+  ],
+  list: [
+    { type: "filter", scope: "actions" },
+    {
+      type: "addNew",
+      scope: "actions",
+      popup: {
+        tryTemplate: true,
+        [FLOW_SURFACE_INTERNAL_AUTO_SAVE_DEFAULT_POPUP_TEMPLATE_KEY]: true
+      }
+    },
+    { type: "refresh", scope: "actions" }
+  ],
+  gridCard: [
+    { type: "filter", scope: "actions" },
+    {
+      type: "addNew",
+      scope: "actions",
+      popup: {
+        tryTemplate: true,
+        [FLOW_SURFACE_INTERNAL_AUTO_SAVE_DEFAULT_POPUP_TEMPLATE_KEY]: true
+      }
+    },
+    { type: "refresh", scope: "actions" }
+  ],
+  calendar: [
+    { type: "filter", scope: "actions" },
+    {
+      type: "addNew",
+      scope: "actions",
+      popup: {
+        tryTemplate: true,
+        [FLOW_SURFACE_INTERNAL_AUTO_SAVE_DEFAULT_POPUP_TEMPLATE_KEY]: true
+      }
+    },
+    { type: "refresh", scope: "actions" }
+  ],
+  kanban: [
+    { type: "filter", scope: "actions" },
+    {
+      type: "addNew",
+      scope: "actions",
+      popup: {
+        tryTemplate: true,
+        [FLOW_SURFACE_INTERNAL_AUTO_SAVE_DEFAULT_POPUP_TEMPLATE_KEY]: true
+      }
+    },
+    { type: "refresh", scope: "actions" }
+  ],
+  createForm: [{ type: "submit", scope: "actions" }],
+  editForm: [{ type: "submit", scope: "actions" }],
+  details: [
+    {
+      type: "edit",
+      scope: "recordActions",
+      popup: {
+        tryTemplate: true,
+        defaultType: "edit",
+        [FLOW_SURFACE_INTERNAL_AUTO_SAVE_DEFAULT_POPUP_TEMPLATE_KEY]: true
+      }
+    }
+  ]
+};
+function cloneDefaultActionDescriptor(descriptor) {
+  return {
+    ...descriptor,
+    ...descriptor.popup ? { popup: import_lodash.default.cloneDeep(descriptor.popup) } : {}
+  };
+}
+function normalizeActionType(value) {
+  return typeof value === "string" ? value.trim() : String(value || "").trim();
+}
+function resolveDefaultBlockActions(blockType, template) {
+  const normalizedBlockType = normalizeActionType(blockType);
+  if (!normalizedBlockType || !import_lodash.default.isUndefined(template)) {
+    return [];
+  }
+  return (FLOW_SURFACE_DEFAULT_BLOCK_ACTIONS[normalizedBlockType] || []).map(cloneDefaultActionDescriptor);
+}
+function shouldMergeDefaultPopup(popup) {
+  if (!import_lodash.default.isPlainObject(popup)) {
+    return true;
+  }
+  const keys = Object.keys(popup);
+  if (!keys.length) {
+    return true;
+  }
+  return keys.every(
+    (key) => ["mode", "size", "title", "defaultType", "tryTemplate", import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY].includes(
+      key
+    )
+  );
+}
+function mergeExplicitActionWithDescriptor(item, descriptor) {
+  if (!descriptor.popup || !shouldMergeDefaultPopup(item == null ? void 0 : item.popup)) {
+    return item;
+  }
+  return {
+    ...item,
+    popup: import_lodash.default.isPlainObject(item == null ? void 0 : item.popup) ? {
+      ...import_lodash.default.cloneDeep(descriptor.popup),
+      ...import_lodash.default.cloneDeep(item.popup)
+    } : import_lodash.default.cloneDeep(descriptor.popup)
+  };
+}
+function mergeDefaultActionList(existing, descriptors, createAction) {
+  const existingList = Array.isArray(existing) ? existing : [];
+  if (!descriptors.length) {
+    return [...existingList];
+  }
+  const defaultTypes = new Set(descriptors.map((descriptor) => descriptor.type));
+  const explicitByType = /* @__PURE__ */ new Map();
+  const extras = [];
+  for (const item of existingList) {
+    const type = normalizeActionType(item == null ? void 0 : item.type);
+    if (!type || !defaultTypes.has(type)) {
+      extras.push(item);
+      continue;
+    }
+    if (!explicitByType.has(type)) {
+      explicitByType.set(type, item);
+      continue;
+    }
+    extras.push(item);
+  }
+  return [
+    ...descriptors.map((descriptor) => {
+      const explicit = explicitByType.get(descriptor.type);
+      return explicit ? mergeExplicitActionWithDescriptor(explicit, descriptor) : createAction(descriptor);
+    }),
+    ...extras
+  ];
+}
+function getFlowSurfaceDefaultBlockActions(input) {
+  return resolveDefaultBlockActions(input.blockType, input.template);
+}
+function mergeFlowSurfaceDefaultBlockActions(input) {
+  const descriptors = resolveDefaultBlockActions(input.blockType, input.template);
+  const actionDescriptors = descriptors.filter((descriptor) => descriptor.scope === "actions");
+  const recordActionDescriptors = descriptors.filter((descriptor) => descriptor.scope === "recordActions");
+  return {
+    actions: mergeDefaultActionList(input.actions, actionDescriptors, input.createAction),
+    recordActions: mergeDefaultActionList(input.recordActions, recordActionDescriptors, input.createAction)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FLOW_SURFACE_INTERNAL_AUTO_SAVE_DEFAULT_POPUP_TEMPLATE_KEY,
+  getFlowSurfaceDefaultBlockActions,
+  mergeFlowSurfaceDefaultBlockActions
+});

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

@@ -0,0 +1,47 @@
+/**
+ * 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 FlowSurfaceErrorType = 'bad_request' | 'forbidden' | 'conflict' | 'internal_error';
+export interface FlowSurfaceErrorItem {
+    message: string;
+    type: FlowSurfaceErrorType;
+    code: string;
+    status: number;
+}
+export declare class FlowSurfaceError extends Error {
+    readonly status: number;
+    readonly type: FlowSurfaceErrorType;
+    readonly code: string;
+    constructor(message: string, status: number, type: FlowSurfaceErrorType, code: string);
+    toResponseBody(): {
+        errors: FlowSurfaceErrorItem[];
+    };
+}
+export declare class FlowSurfaceBadRequestError extends FlowSurfaceError {
+    constructor(message: string, code?: string);
+}
+export declare class FlowSurfaceForbiddenError extends FlowSurfaceError {
+    constructor(message: string, code?: string);
+}
+export declare class FlowSurfaceConflictError extends FlowSurfaceError {
+    constructor(message: string, code?: string);
+}
+export declare class FlowSurfaceInternalError extends FlowSurfaceError {
+    constructor(message: string, code?: string);
+}
+export declare function isFlowSurfaceError(error: unknown): error is FlowSurfaceError;
+export declare function isFlowSurfaceBadRequestError(error: unknown): error is FlowSurfaceBadRequestError;
+export declare function isFlowSurfaceForbiddenError(error: unknown): error is FlowSurfaceForbiddenError;
+export declare function isFlowSurfaceConflictError(error: unknown): error is FlowSurfaceConflictError;
+export declare function isFlowSurfaceInternalError(error: unknown): error is FlowSurfaceInternalError;
+export declare function toFlowSurfaceErrorItem(error: FlowSurfaceError): FlowSurfaceErrorItem;
+export declare function normalizeFlowSurfaceError(error: unknown): FlowSurfaceError;
+export declare function throwBadRequest(message: string, code?: string): never;
+export declare function throwForbidden(message: string, code?: string): never;
+export declare function throwConflict(message: string, code?: string): never;
+export declare function throwInternalError(message: string, code?: string): never;