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

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

@@ -0,0 +1,178 @@
+/**
+ * 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"));
+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" }
+  ],
+  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"].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/service-utils.d.ts

@@ -66,10 +66,10 @@ export type NormalizedComposeFieldSpec = {
 };
 export declare function normalizeComposeFieldSpec(input: any, index: number): NormalizedComposeFieldSpec;
 export declare function normalizeComposeActionSpec(input: any, index: number): {
+    popup?: any;
     key: string;
     type: string;
     settings: any;
-    popup: any;
 };
 export declare function normalizeSimpleResourceInit(input: any): _.Dictionary<any>;
 export declare function isMissingRequiredResourceInitValue(value: any): boolean;

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

@@ -346,8 +346,7 @@ function normalizeComposeActionSpec(input, index) {
     return {
       key: type2,
       type: type2,
-      settings: {},
-      popup: void 0
+      settings: {}
     };
   }
   if (!import_lodash.default.isPlainObject(input)) {
@@ -367,11 +366,12 @@ function normalizeComposeActionSpec(input, index) {
     String(input.key || type).trim(),
     `flowSurfaces compose action #${index + 1}`
   );
+  const popup = import_lodash.default.isPlainObject(input.popup) ? input.popup : void 0;
   return {
     key,
     type,
     settings: import_lodash.default.isPlainObject(input.settings) ? input.settings : {},
-    popup: import_lodash.default.isPlainObject(input.popup) ? input.popup : void 0
+    ...popup ? { popup } : {}
   };
 }
 function normalizeSimpleResourceInit(input) {

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

@@ -39,6 +39,7 @@ export declare class FlowSurfacesService {
     get locator(): SurfaceLocator;
     private get routeSync();
     private getFlowTemplateRepository;
+    private getFlowTemplateRepositorySafe;
     private getFlowTemplateUsageRepository;
     private getFlowTemplateUsageModel;
     private getFlowTemplateUsageRepositorySafe;
@@ -358,6 +359,7 @@ export declare class FlowSurfacesService {
         transaction?: any;
         deferAutoLayout?: boolean;
         enabledPackages?: ReadonlySet<string>;
+        skipDefaultBlockActions?: boolean;
     }): any;
     addField(values: Record<string, any>, options?: {
         transaction?: any;
@@ -424,6 +426,13 @@ export declare class FlowSurfacesService {
     private hasInlinePopupSaveAsTemplateSource;
     private assertInlinePopupSaveAsTemplateSource;
     private clearPopupSurfaceKeys;
+    private buildLegacyAutoGeneratedPopupTemplateMetadata;
+    private formatAutoGeneratedPopupTemplateMetadata;
+    private formatAutoGeneratedActionPopupTemplateMetadata;
+    private resolveFieldBindingContext;
+    private resolveAutoGeneratedFieldPopupTemplateMetadata;
+    private shouldAutoSaveDefaultActionPopupTemplate;
+    private resolveAutoGeneratedActionPopupTemplateMetadata;
     private savePopupAsTemplate;
     private buildInlinePopupTemplateOpenView;
     private peekInlineFieldSettingsOpenView;
@@ -437,6 +446,7 @@ export declare class FlowSurfacesService {
     private getPopupTryTemplateExpectedAssociationName;
     private getPopupTryTemplatePriority;
     private getRequestedPopupDefaultType;
+    private getPopupTryTemplateAllowedDefaultTypes;
     private inferPopupDefaultTypeFromTemplateTree;
     private popupTemplateMatchesDefaultType;
     private tryResolvePopupTemplateForHost;
@@ -466,6 +476,7 @@ export declare class FlowSurfacesService {
     private buildDefaultFieldPopupFieldPaths;
     private buildDefaultFieldPopupBlocks;
     private autoSaveDefaultFieldPopupAsTemplate;
+    private autoSaveDefaultActionPopupAsTemplate;
     private shouldAutoCompleteDefaultActionPopup;
     private buildDefaultActionPopupFieldPaths;
     private buildDefaultActionPopupNamespace;
@@ -589,6 +600,10 @@ export declare class FlowSurfacesService {
     private inspectRecordActionContainer;
     private materializeRecordActionContainer;
     private runBatchCreate;
+    private buildInjectedComposeDefaultActionSpec;
+    private normalizeComposeFieldsLayout;
+    private normalizeComposeFieldsLayoutCell;
+    private applyDefaultActionsForCreatedBlock;
     private normalizeComposeBlock;
     private normalizeComposeBlocks;
     private resolveComposeActionContainerUid;
@@ -651,6 +666,7 @@ export declare class FlowSurfacesService {
     private buildFilterFormTargetPaths;
     private getEditableDomains;
     private resolveContextSemantic;
+    private resolveRecordActionContextOwner;
     private loadContextAncestorChain;
     private resolveCollectionFromInit;
     private buildChartContextSemantic;