@nocobase/plugin-flow-engine 2.1.0-beta.23 → 2.1.0-beta.25

package/dist/server/flow-surfaces/public-compatibility.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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_DEFAULT_SORTING: {
+    field: string;
+    direction: string;
+}[];
+type NormalizeSortingAliasInput = {
+    context: string;
+    type?: string;
+    use?: string;
+    settings?: any;
+};
+export declare function normalizeFlowSurfaceDefaultSorting(input: any, context: string): {
+    field: string;
+    direction: string;
+}[];
+export declare function normalizeFlowSurfaceEmptySortingAsDefault(input: any, context: string): {
+    field: string;
+    direction: string;
+}[];
+export declare function normalizeFlowSurfacePublicSortingAlias(input: NormalizeSortingAliasInput): any;
+export {};

package/dist/server/flow-surfaces/public-compatibility.js

@@ -0,0 +1,161 @@
+/**
+ * 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 public_compatibility_exports = {};
+__export(public_compatibility_exports, {
+  FLOW_SURFACE_DEFAULT_SORTING: () => FLOW_SURFACE_DEFAULT_SORTING,
+  normalizeFlowSurfaceDefaultSorting: () => normalizeFlowSurfaceDefaultSorting,
+  normalizeFlowSurfaceEmptySortingAsDefault: () => normalizeFlowSurfaceEmptySortingAsDefault,
+  normalizeFlowSurfacePublicSortingAlias: () => normalizeFlowSurfacePublicSortingAlias
+});
+module.exports = __toCommonJS(public_compatibility_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_configure_options = require("./configure-options");
+var import_errors = require("./errors");
+var import_support_matrix = require("./support-matrix");
+const FLOW_SURFACE_DEFAULT_SORTING = [{ field: "createdAt", direction: "desc" }];
+function resolveBlockUse(input) {
+  var _a;
+  const explicitUse = String(input.use || "").trim();
+  if (explicitUse) {
+    return explicitUse;
+  }
+  const typeOrUse = String(input.type || "").trim();
+  if (!typeOrUse) {
+    return void 0;
+  }
+  if (import_support_matrix.FLOW_SURFACE_BLOCK_SUPPORT_BY_USE.has(typeOrUse)) {
+    return typeOrUse;
+  }
+  return ((_a = import_support_matrix.FLOW_SURFACE_BLOCK_SUPPORT_BY_KEY.get(typeOrUse)) == null ? void 0 : _a.modelUse) || typeOrUse;
+}
+function blockSupportsSorting(use) {
+  return !!use && (0, import_configure_options.getConfigureOptionKeysForUse)(use).includes("sorting");
+}
+function normalizeSortingDirection(input, context) {
+  const normalized = String(input || "").trim().toLowerCase();
+  if (!normalized || normalized === "asc" || normalized === "ascend" || normalized === "ascending") {
+    return "asc";
+  }
+  if (normalized === "desc" || normalized === "descend" || normalized === "descending") {
+    return "desc";
+  }
+  (0, import_errors.throwBadRequest)(`${context} must be 'asc' or 'desc'`);
+}
+function normalizeSortingField(input, context) {
+  const field = String(input || "").trim();
+  if (!field) {
+    (0, import_errors.throwBadRequest)(`${context} must be a non-empty field name`);
+  }
+  return field;
+}
+function normalizeSortingEntry(input, context) {
+  if (import_lodash.default.isString(input)) {
+    const value = input.trim();
+    if (!value) {
+      (0, import_errors.throwBadRequest)(`${context} must be a non-empty sort field`);
+    }
+    const descending = value.startsWith("-");
+    const field = descending ? value.slice(1).trim() : value;
+    return {
+      field: normalizeSortingField(field, context),
+      direction: descending ? "desc" : "asc"
+    };
+  }
+  if (!import_lodash.default.isPlainObject(input)) {
+    (0, import_errors.throwBadRequest)(`${context} must be a string or an object with field and direction`);
+  }
+  return {
+    field: normalizeSortingField(input.field, `${context}.field`),
+    direction: normalizeSortingDirection(input.direction, `${context}.direction`)
+  };
+}
+function normalizeSortingArray(input, context) {
+  if (!Array.isArray(input)) {
+    (0, import_errors.throwBadRequest)(`${context} must be an array`);
+  }
+  return input.map((item, index) => normalizeSortingEntry(item, `${context}[${index}]`));
+}
+function normalizeFlowSurfaceDefaultSorting(input, context) {
+  if (Array.isArray(input)) {
+    return normalizeSortingArray(input, context);
+  }
+  if (import_lodash.default.isUndefined(input) || import_lodash.default.isNull(input)) {
+    return import_lodash.default.cloneDeep(FLOW_SURFACE_DEFAULT_SORTING);
+  }
+  (0, import_errors.throwBadRequest)(`${context} must be an array`);
+}
+function normalizeFlowSurfaceEmptySortingAsDefault(input, context) {
+  if (Array.isArray(input) && !input.length) {
+    return import_lodash.default.cloneDeep(FLOW_SURFACE_DEFAULT_SORTING);
+  }
+  return normalizeFlowSurfaceDefaultSorting(input, context);
+}
+function normalizeFlowSurfacePublicSortingAlias(input) {
+  if (import_lodash.default.isUndefined(input.settings)) {
+    return input.settings;
+  }
+  if (!import_lodash.default.isPlainObject(input.settings)) {
+    (0, import_errors.throwBadRequest)(`${input.context} must be an object`);
+  }
+  if (!Object.prototype.hasOwnProperty.call(input.settings, "sort")) {
+    return input.settings;
+  }
+  const use = resolveBlockUse(input);
+  if (!blockSupportsSorting(use)) {
+    return input.settings;
+  }
+  const nextSettings = import_lodash.default.cloneDeep(input.settings);
+  const sortingFromSort = normalizeFlowSurfaceDefaultSorting(nextSettings.sort, `${input.context}.sort`);
+  if (Object.prototype.hasOwnProperty.call(nextSettings, "sorting")) {
+    const canonicalSorting = normalizeFlowSurfaceDefaultSorting(nextSettings.sorting, `${input.context}.sorting`);
+    if (!import_lodash.default.isEqual(sortingFromSort, canonicalSorting)) {
+      (0, import_errors.throwBadRequest)(`${input.context}.sort conflicts with ${input.context}.sorting; use canonical sorting`);
+    }
+    nextSettings.sorting = canonicalSorting;
+  } else {
+    nextSettings.sorting = sortingFromSort;
+  }
+  delete nextSettings.sort;
+  return nextSettings;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FLOW_SURFACE_DEFAULT_SORTING,
+  normalizeFlowSurfaceDefaultSorting,
+  normalizeFlowSurfaceEmptySortingAsDefault,
+  normalizeFlowSurfacePublicSortingAlias
+});

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

@@ -69,7 +69,6 @@ export type NormalizedComposeFieldSpec = {
     type?: string;
     fieldType?: FlowSurfacePublicRelationFieldType;
     fields?: string[];
-    selectorFields?: string[];
     titleField?: string;
     openMode?: string;
     popupSize?: string;

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

@@ -388,10 +388,6 @@ function normalizeComposeFieldSpec(input, index) {
   const renderer = typeof input.renderer === "undefined" ? void 0 : String(input.renderer || "").trim();
   const fieldType = (0, import_field_type_resolver.normalizePublicFieldType)(input.fieldType, `compose field #${index + 1}`);
   const fields = (0, import_field_type_resolver.normalizePublicFieldNameList)(input.fields, `compose field #${index + 1}.fields`);
-  const selectorFields = (0, import_field_type_resolver.normalizePublicFieldNameList)(
-    input.selectorFields,
-    `compose field #${index + 1}.selectorFields`
-  );
   const titleField = typeof input.titleField === "undefined" ? void 0 : String(input.titleField || "").trim();
   const openMode = typeof input.openMode === "undefined" ? void 0 : String(input.openMode || "").trim();
   const popupSize = typeof input.popupSize === "undefined" ? void 0 : String(input.popupSize || "").trim();
@@ -423,7 +419,6 @@ function normalizeComposeFieldSpec(input, index) {
     ...semanticType ? { type: semanticType } : {},
     ...fieldType ? { fieldType } : {},
     ...!import_lodash.default.isUndefined(fields) ? { fields } : {},
-    ...!import_lodash.default.isUndefined(selectorFields) ? { selectorFields } : {},
     ...titleField ? { titleField } : {},
     ...openMode ? { openMode } : {},
     ...popupSize ? { popupSize } : {},
@@ -665,7 +660,6 @@ function splitComposeFieldChanges(changes, wrapperUse) {
     "name",
     "fieldType",
     "fields",
-    "selectorFields",
     "titleField",
     "openMode",
     "popupSize",

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

@@ -10,9 +10,9 @@ import type { Plugin } from '@nocobase/server';
 import _ from 'lodash';
 import FlowModelRepository from '../repository';
 import { SurfaceLocator } from './locator';
-import { type TemplateTranslate } from './template-display';
+import type { TemplateTranslate } from './template-display';
 import type { FlowSurfaceActionLinkageRule, FlowSurfaceBlockLinkageRule, FlowSurfaceFieldLinkageRule, FlowSurfaceFieldValueRule, FlowSurfaceGetReactionMetaResult, FlowSurfaceGetReactionMetaValues, FlowSurfaceReactionWriteResult, FlowSurfaceReactionWriteValues } from './reaction/types';
-import { type FlowSurfaceTemplateListPopupActionContext, type FlowSurfaceTemplateListValues, type FlowSurfaceTemplateRow } from './template-service-utils';
+import type { FlowSurfaceTemplateListPopupActionContext, FlowSurfaceTemplateListValues, FlowSurfaceTemplateRow } from './template-service-utils';
 import type { FlowSurfaceApplyValues, FlowSurfaceCatalogResponse, FlowSurfaceCatalogValues, FlowSurfaceComposeValues, FlowSurfaceConfigureValues, FlowSurfaceContextValues, FlowSurfaceDescribeValues, FlowSurfaceMutateValues } from './types';
 type FlowSurfacePopupTemplateAliasSession = Map<string, string>;
 type FlowSurfaceAddFieldResult = {
@@ -48,6 +48,7 @@ export declare class FlowSurfacesService {
     private get surfaceContext();
     private get approvalRuntimeConfigService();
     private get approvalBlueprintService();
+    private get hiddenPopupRuntime();
     private setFlowModelNodeAsyncFlag;
     private loadEnabledPluginPackages;
     private resolveEnabledPluginPackages;
@@ -77,6 +78,7 @@ export declare class FlowSurfacesService {
     private patchResolvedNodeConfigureOptions;
     private buildRelationFieldTypeCandidates;
     private collectRelationNestedFieldPaths;
+    private collectRelationFieldPaths;
     private collectRelationSelectorFieldPaths;
     private projectCatalogItem;
     private buildCatalogBlockItem;
@@ -86,6 +88,7 @@ export declare class FlowSurfacesService {
     private isCatalogBlockVisibleForPopupProfile;
     private getPopupCollectionBlockScenes;
     private isPopupCollectionBlockSceneUnsupported;
+    private supportsPopupAssociatedRecordsBinding;
     private isPopupCollectionBlockVisibleForScene;
     private resolveFieldAssociationContextFromBinding;
     private resolvePopupHostFieldAssociationContext;
@@ -96,6 +99,7 @@ export declare class FlowSurfacesService {
     private buildPopupBlockResourceBindings;
     private listPopupAssociatedRecordFields;
     private resolvePopupBlockProfile;
+    private resolvePopupCurrentRecordResourceFilterByTk;
     private resolvePopupAssociationFields;
     private findPopupHostNode;
     private getBlockKeyByUse;
@@ -104,6 +108,8 @@ export declare class FlowSurfacesService {
     private assertRequiredBlockResourceInit;
     private describeComposeBlock;
     private resolvePopupCollectionBlockResourceInit;
+    private shouldUseLegacyAssociationPopupCurrentRecordBinding;
+    private shouldNormalizeLegacyAssociationPopupRecordBlockResource;
     private compilePopupSemanticResourceInit;
     private assertPopupRawResourceInit;
     private validatePopupRawResourceInit;
@@ -225,6 +231,9 @@ export declare class FlowSurfacesService {
     private inferSaveTemplateTarget;
     private createFlowTemplateReferenceBlockModel;
     private buildPopupTemplateReferenceOpenView;
+    private shouldHydrateDetachedPopupTemplateBlockResourceContext;
+    private collectDetachedPopupTemplateBlockResourceContextPatches;
+    private hydrateDetachedPopupTemplateBlockResourceContext;
     private hydrateDetachedPopupTemplateSourceContext;
     private clearFlowTemplateUsagesByModelUids;
     private clearFlowTemplateUsagesForNodeTree;
@@ -432,6 +441,9 @@ export declare class FlowSurfacesService {
     private validateComposePopupTemplateAliases;
     private validateApplyBlueprintPopupTemplateAliases;
     private normalizeInlineSettings;
+    private shouldEnableCreatedAtDefaultSorting;
+    private normalizeBlockSortingInput;
+    private normalizeMapSortingInput;
     private normalizeInlinePopup;
     private normalizePopupSaveAsTemplate;
     private hasInlinePopupSaveAsTemplateSource;
@@ -443,6 +455,9 @@ export declare class FlowSurfacesService {
     private resolveFieldBindingContext;
     private resolveAutoGeneratedFieldPopupTemplateMetadata;
     private shouldAutoSaveDefaultActionPopupTemplate;
+    private resolveDefaultActionPopupSemanticUse;
+    private getDefaultActionPopupConfigForNode;
+    private isDefaultActionPopupUseForNode;
     private shouldImplicitlyTemplateDefaultActionPopup;
     private buildImplicitTemplateDefaultActionPopup;
     private resolveAutoGeneratedActionPopupTemplateMetadata;
@@ -460,6 +475,7 @@ export declare class FlowSurfacesService {
     private getDefaultFlowTemplateSort;
     private getPopupTryTemplateExpectedAssociationName;
     private getPopupTryTemplatePriority;
+    private shouldRequireExactPopupTryTemplateAssociation;
     private getRequestedPopupDefaultType;
     private getPopupTryTemplateAllowedDefaultTypes;
     private inferPopupDefaultTypeFromTemplateTree;
@@ -468,6 +484,7 @@ export declare class FlowSurfacesService {
     private getFlowTemplateOrThrow;
     private buildPopupTemplateOpenView;
     private isReferencedPopupTemplateOpenView;
+    private isPopupTemplateReferenceOpenViewState;
     private isEditableDefaultActionPopupTemplateReference;
     private resolveExternalPopupHostUid;
     private resolveDetachedPopupCopyUid;
@@ -529,9 +546,11 @@ export declare class FlowSurfacesService {
     updateSettings(values: Record<string, any>, options?: {
         transaction?: any;
         replaceChartCardSettings?: boolean;
+        replacePopupStepParamSubtrees?: boolean;
         openViewActionName?: string;
         popupTemplateHostUid?: string;
         popupActionContext?: FlowSurfaceTemplateListPopupActionContext;
+        skipHiddenPopupHostEnsure?: boolean;
     }): Promise<{
         uid: any;
         updated?: undefined;
@@ -539,8 +558,20 @@ export declare class FlowSurfacesService {
         uid: any;
         updated: string[];
     }>;
+    private syncCalendarPopupPropsForUpdateSettings;
+    private replaceExplicitPopupStepParamSubtreesForUpdateSettings;
+    private normalizePopupStepParamReplacementForUpdateSettings;
+    private stripPopupPropsFromPayload;
+    private syncDefaultSortingForUpdateSettings;
+    private syncKanbanPopupPropsForUpdateSettings;
     private syncFilterActionSettingsForUpdateSettings;
     private syncMirroredStepParamsForUpdateSettings;
+    private syncUpdateActionAssignedValuesForUpdateSettings;
+    private syncUpdateActionAssignFormItems;
+    private ensureUpdateActionAssignForm;
+    private ensureUpdateActionAssignFormGrid;
+    private buildUpdateActionAssignFormItemTree;
+    private resolveUpdateActionAssignFormFieldUse;
     private normalizeCanonicalBlockHeaderWriteForUpdateSettings;
     private syncCanonicalBlockHeaderForUpdateSettings;
     private stripLegacyBlockHeaderChromeForUpdateSettings;
@@ -630,10 +661,15 @@ export declare class FlowSurfacesService {
     private resolveComposeBlockActionCatalogItem;
     private resolveComposeRecordActionCatalogItem;
     private isAddChildCatalogItem;
+    private resolveTreeChildrenField;
+    private resolveTreeChildrenAssociationName;
     private isTreeCollection;
     private isTreeTableEnabled;
     private resolveAddChildOwnerNode;
+    private resolveAddChildOwnerResourceContext;
     private resolveOwnerCollectionForAddChild;
+    private resolveAddChildResourceInitForOwnerNode;
+    private normalizeAddChildOpenViewForAction;
     private canUseAddChildOnOwnerNode;
     private assertAddChildSupportedForOwnerNode;
     private filterTargetRecordActions;
@@ -690,6 +726,7 @@ export declare class FlowSurfacesService {
     private configureFieldWrapper;
     private configureFieldNode;
     private normalizeFilterActionDefaultFilterValue;
+    private normalizeActionAssignValues;
     private configureActionNode;
     private normalizeActionPanelActionChanges;
     private buildFieldCatalog;
@@ -734,6 +771,12 @@ export declare class FlowSurfacesService {
     private resolveContextOwnerCollection;
     private resolveItemContextCollection;
     private resolvePopupHostOpenView;
+    private popupHostHasLocalContent;
+    private shouldAutoBindPopupTemplate;
+    private patchPopupOpenViewIfChanged;
+    private buildPopupOpenViewWithTemplate;
+    private completePopupHostDefaultContent;
+    private ensurePopupHostDefaultContent;
     private resolvePopupSourceRecordCollectionName;
     private resolvePopupContextLevel;
     private getCollection;
@@ -758,10 +801,14 @@ export declare class FlowSurfacesService {
     private buildKanbanInlineGroupOptions;
     private mergeKanbanInlineGroupOptions;
     private normalizeKanbanPopupSettings;
-    private getKanbanPopupActionUse;
     private getKanbanPopupActionUid;
     private getKanbanBlockResourceInit;
+    private buildKanbanInitialStepParams;
+    private buildKanbanInitialItemProps;
+    private buildKanbanInitialItemStepParams;
     private getKanbanPopupStoredSettings;
+    private mergeKanbanPopupSettings;
+    private stripKanbanPopupTargetSettingsForResourceChange;
     private buildKanbanPopupOpenView;
     private normalizeKanbanPopupConfigureValue;
     private buildKanbanInitialBlockProps;
@@ -782,21 +829,27 @@ export declare class FlowSurfacesService {
     private assertCalendarFieldBinding;
     private normalizeCalendarFieldNamesForCollection;
     private normalizeCalendarPopupSettings;
-    private getCalendarPopupActionUse;
-    private getCalendarPopupPropKey;
-    private getCalendarPopupActionUid;
     private getCalendarBlockResourceInit;
+    private getCalendarPopupStoredSettings;
+    private getCalendarPopupPropKey;
+    private buildCalendarInitialStepParams;
     private buildCalendarPopupOpenView;
+    private mergeCalendarPopupSettings;
+    private stripCalendarPopupTargetSettingsForResourceChange;
     private normalizeCalendarPopupConfigureValue;
+    private normalizeCalendarInlineSettingsForConfigure;
+    private omitHiddenPopupSettingsForConfigure;
+    private resolveCalendarInitialPopupOverride;
+    private resolveKanbanInitialPopupOverride;
     private buildCalendarInitialBlockProps;
     private ensureCalendarBlockPopupHosts;
-    private ensureCalendarBlockPopupHostsInTree;
-    private projectCalendarBlockPopupHosts;
     private projectCalendarBlockPopupHostsInTree;
+    private replaceKanbanStoredPopupSettings;
     private ensureKanbanBlockPopupHosts;
-    private ensureKanbanBlockPopupHostsInTree;
-    private projectKanbanBlockPopupHosts;
     private projectKanbanBlockPopupHostsInTree;
+    private resolveManagedPopupTargetUidForHiddenPopupBackfill;
+    private ensureHiddenPopupBlockHostsInManagedPopupTarget;
+    private ensureHiddenPopupBlockHostsInTree;
     private getCalendarSettingValue;
     private validateCalendarSettingValues;
     private validateCalendarBlockState;
@@ -815,6 +868,8 @@ export declare class FlowSurfacesService {
     private ensureFlowRoutePageSchemaShell;
     private removeFlowRoutePageSchemaShell;
     private normalizeDisplayFieldBinding;
+    private collectionFieldHasRequiredValidation;
+    private buildRequiredCollectionFieldFormWrapperDefaults;
     private getCollectionFieldOrBadRequest;
     private buildRelationTargetFieldInit;
     private buildRelationTargetTableColumnNode;
@@ -824,6 +879,7 @@ export declare class FlowSurfacesService {
     private ensureFieldGridSubModel;
     private applyResolvedRelationFieldType;
     private applyRecordPickerFieldTypeSettings;
+    private ensureRelationSelectorGridTable;
     private buildExactFieldSettingsInitPayload;
     private patchFieldSettingsInitExact;
     private inferFieldComponentFlowDomain;