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

package/dist/server/flow-surfaces/field-type-resolver.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 field_type_resolver_exports = {};
+__export(field_type_resolver_exports, {
+  FLOW_SURFACE_INTERNAL_FIELD_KEYS: () => FLOW_SURFACE_INTERNAL_FIELD_KEYS,
+  FLOW_SURFACE_PUBLIC_FIELD_TYPE_SET: () => FLOW_SURFACE_PUBLIC_FIELD_TYPE_SET,
+  FLOW_SURFACE_PUBLIC_RELATION_FIELD_TYPES: () => FLOW_SURFACE_PUBLIC_RELATION_FIELD_TYPES,
+  FLOW_SURFACE_RESERVED_RELATION_FIELD_TYPES: () => FLOW_SURFACE_RESERVED_RELATION_FIELD_TYPES,
+  assertNoInternalFieldKeys: () => assertNoInternalFieldKeys,
+  getPublicFieldTypeForUse: () => getPublicFieldTypeForUse,
+  normalizePublicFieldNameList: () => normalizePublicFieldNameList,
+  normalizePublicFieldType: () => normalizePublicFieldType,
+  resolveRelationFieldType: () => resolveRelationFieldType,
+  usesNestedRelationFields: () => usesNestedRelationFields
+});
+module.exports = __toCommonJS(field_type_resolver_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("./errors");
+var import_association_interfaces = require("./association-interfaces");
+var import_field_semantics = require("./field-semantics");
+var import_service_helpers = require("./service-helpers");
+var import_association_title_field = require("./association-title-field");
+const FLOW_SURFACE_PUBLIC_RELATION_FIELD_TYPES = [
+  "text",
+  "select",
+  "picker",
+  "subForm",
+  "subFormList",
+  "subDetails",
+  "subDetailsList",
+  "subTable",
+  "popupSubTable"
+];
+const FLOW_SURFACE_RESERVED_RELATION_FIELD_TYPES = ["cascade", "upload", "preview"];
+const FLOW_SURFACE_PUBLIC_FIELD_TYPE_SET = /* @__PURE__ */ new Set([
+  ...FLOW_SURFACE_PUBLIC_RELATION_FIELD_TYPES,
+  ...FLOW_SURFACE_RESERVED_RELATION_FIELD_TYPES
+]);
+const FLOW_SURFACE_INTERNAL_FIELD_KEYS = [
+  "fieldComponent",
+  "fieldModel",
+  "componentFields",
+  "use",
+  "fieldUse",
+  "subModels",
+  "props",
+  "stepParams"
+];
+const FIELD_USE_TO_PUBLIC_FIELD_TYPE = {
+  DisplayTextFieldModel: "text",
+  RecordSelectFieldModel: "select",
+  RecordPickerFieldModel: "picker",
+  SubFormFieldModel: "subForm",
+  SubFormListFieldModel: "subFormList",
+  DisplaySubItemFieldModel: "subDetails",
+  DisplaySubListFieldModel: "subDetailsList",
+  DisplaySubTableFieldModel: "subTable",
+  SubTableFieldModel: "subTable",
+  PopupSubTableFieldModel: "popupSubTable"
+};
+const FIELD_TYPES_WITH_FIELDS = /* @__PURE__ */ new Set([
+  "subForm",
+  "subFormList",
+  "subDetails",
+  "subDetailsList",
+  "subTable",
+  "popupSubTable"
+]);
+const FIELD_TYPES_WITH_SELECTOR_FIELDS = /* @__PURE__ */ new Set(["picker"]);
+const FIELD_TYPES_WITH_TABLE_PROPS = /* @__PURE__ */ new Set(["subTable", "popupSubTable"]);
+function assertNoInternalFieldKeys(input, context) {
+  if (!import_lodash.default.isPlainObject(input)) {
+    return;
+  }
+  const forbidden = FLOW_SURFACE_INTERNAL_FIELD_KEYS.filter((key) => Object.prototype.hasOwnProperty.call(input, key));
+  if (forbidden.length) {
+    (0, import_errors.throwBadRequest)(`${context} does not accept internal field keys: ${forbidden.join(", ")}`);
+  }
+}
+function normalizePublicFieldType(value, context) {
+  if (import_lodash.default.isUndefined(value) || import_lodash.default.isNull(value) || value === "") {
+    return void 0;
+  }
+  const normalized = String(value || "").trim();
+  if (!normalized) {
+    return void 0;
+  }
+  if (FLOW_SURFACE_RESERVED_RELATION_FIELD_TYPES.includes(normalized)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${context} fieldType '${normalized}' is reserved for plugin-specific field types`);
+  }
+  if (!FLOW_SURFACE_PUBLIC_RELATION_FIELD_TYPES.includes(normalized)) {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${context} fieldType '${normalized}' is not supported; supported fieldTypes: ${FLOW_SURFACE_PUBLIC_RELATION_FIELD_TYPES.join(
+        ", "
+      )}`
+    );
+  }
+  return normalized;
+}
+function normalizePublicFieldNameList(value, context) {
+  if (import_lodash.default.isUndefined(value)) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${context} must be an array of field names`);
+  }
+  return value.map((item, index) => {
+    const normalized = String(item || "").trim();
+    if (!normalized) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${context}[${index + 1}] cannot be empty`);
+    }
+    return normalized;
+  });
+}
+function getPublicFieldTypeForUse(use) {
+  return FIELD_USE_TO_PUBLIC_FIELD_TYPE[String(use || "").trim()];
+}
+function getAssociationCardinality(field) {
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim();
+  if (import_association_interfaces.SINGLE_VALUE_ASSOCIATION_INTERFACES.has(fieldInterface)) {
+    return "single";
+  }
+  if (import_association_interfaces.MULTI_VALUE_ASSOCIATION_INTERFACES.has(fieldInterface)) {
+    return "multi";
+  }
+  return null;
+}
+function pickCollectionFallbackFieldName(collection) {
+  var _a;
+  const safeTitleFieldName = (_a = (0, import_association_title_field.resolveCollectionSafeTitleField)(collection)) == null ? void 0 : _a.fieldName;
+  if (safeTitleFieldName && (0, import_service_helpers.resolveFieldFromCollection)(collection, safeTitleFieldName)) {
+    return safeTitleFieldName;
+  }
+  const primaryField = (0, import_service_helpers.getCollectionFields)(collection).find(
+    (field) => {
+      var _a2;
+      return !!(field == null ? void 0 : field.primaryKey) || !!((_a2 = field == null ? void 0 : field.options) == null ? void 0 : _a2.primaryKey);
+    }
+  );
+  return (0, import_service_helpers.getFieldName)(primaryField) || "id";
+}
+function assertTargetFieldNamesExist(targetCollection, fields, context) {
+  fields.forEach((fieldName) => {
+    if (!(0, import_service_helpers.resolveFieldFromCollection)(targetCollection, fieldName)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${context} field '${fieldName}' does not exist on relation target collection`);
+    }
+  });
+}
+function resolveRelationFieldType(input) {
+  const fieldType = normalizePublicFieldType(input.fieldType, input.context);
+  if (!fieldType) {
+    return void 0;
+  }
+  if (!(0, import_service_helpers.isAssociationField)(input.field)) {
+    throw new import_errors.FlowSurfaceBadRequestError("flowSurfaces fieldType is only supported for relation fields");
+  }
+  const targetCollection = (0, import_service_helpers.resolveFieldTargetCollection)(
+    input.field,
+    input.dataSourceKey || "main",
+    input.getCollection
+  );
+  if (!targetCollection) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType '${fieldType}' cannot resolve relation target collection`);
+  }
+  const cardinality = getAssociationCardinality(input.field);
+  if (!cardinality) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType '${fieldType}' is not supported for this relation field`);
+  }
+  const containerKind = (0, import_field_semantics.normalizeFieldContainerKind)(input.containerUse);
+  let fieldUse;
+  switch (fieldType) {
+    case "text":
+      fieldUse = containerKind === "form" ? "RecordSelectFieldModel" : "DisplayTextFieldModel";
+      break;
+    case "select":
+      fieldUse = "RecordSelectFieldModel";
+      break;
+    case "picker":
+      fieldUse = "RecordPickerFieldModel";
+      break;
+    case "subForm":
+      if (cardinality !== "single") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType 'subForm' only supports single relation fields`);
+      }
+      fieldUse = "SubFormFieldModel";
+      break;
+    case "subFormList":
+      if (cardinality !== "multi") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType 'subFormList' only supports multi relation fields`);
+      }
+      fieldUse = "SubFormListFieldModel";
+      break;
+    case "subDetails":
+      if (cardinality !== "single") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType 'subDetails' only supports single relation fields`);
+      }
+      fieldUse = "DisplaySubItemFieldModel";
+      break;
+    case "subDetailsList":
+      if (cardinality !== "multi") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType 'subDetailsList' only supports multi relation fields`);
+      }
+      fieldUse = "DisplaySubListFieldModel";
+      break;
+    case "subTable":
+      if (cardinality !== "multi") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType 'subTable' only supports multi relation fields`);
+      }
+      fieldUse = containerKind === "form" ? "SubTableFieldModel" : "DisplaySubTableFieldModel";
+      break;
+    case "popupSubTable":
+      if (cardinality !== "multi") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType 'popupSubTable' only supports multi relation fields`);
+      }
+      fieldUse = "PopupSubTableFieldModel";
+      break;
+  }
+  const explicitFields = normalizePublicFieldNameList(input.fields, `${input.context}.fields`);
+  const explicitSelectorFields = normalizePublicFieldNameList(input.selectorFields, `${input.context}.selectorFields`);
+  if (explicitFields && explicitSelectorFields) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} cannot mix fields and selectorFields on the same field`);
+  }
+  if (explicitFields && !FIELD_TYPES_WITH_FIELDS.has(fieldType)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType '${fieldType}' does not support fields`);
+  }
+  if (explicitSelectorFields && !FIELD_TYPES_WITH_SELECTOR_FIELDS.has(fieldType)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType '${fieldType}' does not support selectorFields`);
+  }
+  if ((!import_lodash.default.isUndefined(input.openMode) || !import_lodash.default.isUndefined(input.popupSize)) && fieldType !== "picker") {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType '${fieldType}' does not support openMode or popupSize`);
+  }
+  if ((!import_lodash.default.isUndefined(input.pageSize) || !import_lodash.default.isUndefined(input.showIndex)) && !FIELD_TYPES_WITH_TABLE_PROPS.has(fieldType)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType '${fieldType}' does not support pageSize or showIndex`);
+  }
+  const shouldApplyDefaults = input.applyDefaults !== false;
+  const defaultTargetField = shouldApplyDefaults ? pickCollectionFallbackFieldName(targetCollection) : void 0;
+  const fields = explicitFields ?? (shouldApplyDefaults && usesNestedRelationFields(fieldUse) ? [defaultTargetField] : void 0);
+  const selectorFields = explicitSelectorFields ?? (shouldApplyDefaults && fieldType === "picker" && import_lodash.default.isUndefined(input.selectorFields) ? [defaultTargetField] : void 0);
+  const titleField = import_lodash.default.isUndefined(input.titleField) ? defaultTargetField : String(input.titleField || "").trim() || void 0;
+  if (fields == null ? void 0 : fields.length) {
+    assertTargetFieldNamesExist(targetCollection, fields, `${input.context}.fields`);
+  }
+  if (selectorFields == null ? void 0 : selectorFields.length) {
+    assertTargetFieldNamesExist(targetCollection, selectorFields, `${input.context}.selectorFields`);
+  }
+  if (titleField && !(0, import_service_helpers.resolveFieldFromCollection)(targetCollection, titleField)) {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${input.context}.titleField '${titleField}' does not exist on relation target collection`
+    );
+  }
+  return {
+    fieldType,
+    fieldUse,
+    cardinality,
+    targetCollection,
+    fields,
+    selectorFields,
+    titleField,
+    openMode: input.openMode,
+    popupSize: input.popupSize,
+    pageSize: input.pageSize,
+    showIndex: input.showIndex
+  };
+}
+function usesNestedRelationFields(fieldUse) {
+  return [
+    "SubTableFieldModel",
+    "PopupSubTableFieldModel",
+    "DisplaySubTableFieldModel",
+    "SubFormFieldModel",
+    "SubFormListFieldModel",
+    "DisplaySubItemFieldModel",
+    "DisplaySubListFieldModel"
+  ].includes(String(fieldUse || "").trim());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FLOW_SURFACE_INTERNAL_FIELD_KEYS,
+  FLOW_SURFACE_PUBLIC_FIELD_TYPE_SET,
+  FLOW_SURFACE_PUBLIC_RELATION_FIELD_TYPES,
+  FLOW_SURFACE_RESERVED_RELATION_FIELD_TYPES,
+  assertNoInternalFieldKeys,
+  getPublicFieldTypeForUse,
+  normalizePublicFieldNameList,
+  normalizePublicFieldType,
+  resolveRelationFieldType,
+  usesNestedRelationFields
+});

package/dist/server/flow-surfaces/node-use-sets.js

@@ -39,6 +39,7 @@ var import_approval = require("./approval");
 const COLLECTION_BLOCK_USES = /* @__PURE__ */ new Set([
   "TableBlockModel",
   "CalendarBlockModel",
+  "TreeBlockModel",
   "KanbanBlockModel",
   "CreateFormModel",
   "EditFormModel",

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

@@ -9,6 +9,7 @@
 import _ from 'lodash';
 import { FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY, type FlowSurfaceApplyBlueprintPopupDefaultsMetadata } from './blueprint/defaults';
 import type { FlowSurfaceNodeSpec, FlowSurfaceNodeSubModel } from './types';
+import { type FlowSurfacePublicRelationFieldType } from './field-type-resolver';
 export declare function buildDefinedPayload(payload: Record<string, any>): _.Dictionary<any>;
 export declare function normalizeFlowSurfaceComposeKey(key: any, context: string): string;
 export declare function assertFlowSurfaceComposeUniqueKeys(items: Array<{
@@ -65,6 +66,14 @@ export type NormalizedComposeFieldSpec = {
     associationPathName?: string;
     renderer?: string;
     type?: string;
+    fieldType?: FlowSurfacePublicRelationFieldType;
+    fields?: string[];
+    selectorFields?: string[];
+    titleField?: string;
+    openMode?: string;
+    popupSize?: string;
+    pageSize?: number;
+    showIndex?: boolean;
     target?: string;
     settings: Record<string, any>;
     popup?: Record<string, any>;
@@ -72,6 +81,9 @@ export type NormalizedComposeFieldSpec = {
     [FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY]?: FlowSurfaceApplyBlueprintPopupDefaultsMetadata;
 };
 export declare function normalizeComposeFieldSpec(input: any, index: number): NormalizedComposeFieldSpec;
+export declare function resolveRequestedFieldComponent(values: Record<string, any> | undefined): any;
+export declare function resolveRequestedFieldUse(values: Record<string, any> | undefined): any;
+export declare function resolveRequestedFieldUseAlias(values: Record<string, any> | undefined): string;
 export declare function normalizeComposeActionSpec(input: any, index: number): {
     popup?: any;
     key: string;
@@ -99,7 +111,7 @@ export declare function splitComposeFieldChanges(changes: Record<string, any>, w
     wrapperChanges: _.Dictionary<any>;
     fieldChanges: _.Dictionary<any>;
 };
-export declare function getCatalogRecordActionContainerUse(use?: string): "DetailsBlockModel" | "TableActionsColumnModel" | "ListItemModel" | "GridCardItemModel";
+export declare function getCatalogRecordActionContainerUse(use?: string): "DetailsBlockModel" | "ListItemModel" | "GridCardItemModel" | "TableActionsColumnModel";
 export declare function normalizeRowSpans(spans?: Array<number | undefined>): number[];
 export declare function normalizePublicBlockHeightMode(input: any): string;
 export declare function normalizeStoredChartCardHeightMode(input: any): string;

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

@@ -72,6 +72,9 @@ __export(service_utils_exports, {
   normalizeSimpleLayoutValue: () => normalizeSimpleLayoutValue,
   normalizeSimpleResourceInit: () => normalizeSimpleResourceInit,
   normalizeStoredChartCardHeightMode: () => normalizeStoredChartCardHeightMode,
+  resolveRequestedFieldComponent: () => resolveRequestedFieldComponent,
+  resolveRequestedFieldUse: () => resolveRequestedFieldUse,
+  resolveRequestedFieldUseAlias: () => resolveRequestedFieldUseAlias,
   rethrowInlineConfigurationError: () => rethrowInlineConfigurationError,
   splitComposeFieldChanges: () => splitComposeFieldChanges,
   toFlowSurfaceBatchItemError: () => toFlowSurfaceBatchItemError
@@ -84,6 +87,7 @@ var import_defaults = require("./blueprint/defaults");
 var import_errors = require("./errors");
 var import_service_helpers = require("./service-helpers");
 var import_key_registry = require("./planning/key-registry");
+var import_field_type_resolver = require("./field-type-resolver");
 function buildDefinedPayload(payload) {
   return import_lodash.default.pickBy(payload, (value) => !import_lodash.default.isUndefined(value));
 }
@@ -299,7 +303,18 @@ function hasDefinedValue(input, keys) {
   return keys.some((key) => hasOwnDefined(input, key));
 }
 function ensureNoRawSimpleChangeKeys(changes) {
-  const rawKeys = ["props", "decoratorProps", "stepParams", "flowRegistry", "use", "fieldUse"];
+  const rawKeys = [
+    "props",
+    "decoratorProps",
+    "stepParams",
+    "flowRegistry",
+    "use",
+    "fieldUse",
+    "fieldComponent",
+    "fieldModel",
+    "componentFields",
+    "subModels"
+  ];
   const forbidden = Object.keys(changes).filter((key) => rawKeys.includes(key));
   if (forbidden.length) {
     (0, import_errors.throwBadRequest)(
@@ -346,12 +361,22 @@ function normalizeComposeFieldSpec(input, index) {
   if (!import_lodash.default.isPlainObject(input)) {
     (0, import_errors.throwBadRequest)(`flowSurfaces compose field #${index + 1} must be a string or object`);
   }
-  if (input.use || input.fieldUse || input.stepParams || input.props || input.decoratorProps) {
-    (0, import_errors.throwBadRequest)("flowSurfaces compose field only accepts public semantic field fields");
-  }
+  (0, import_field_type_resolver.assertNoInternalFieldKeys)(input, `flowSurfaces compose field #${index + 1}`);
+  (0, import_field_type_resolver.assertNoInternalFieldKeys)(input.settings, `flowSurfaces compose field #${index + 1}.settings`);
   const semanticType = String(input.type || "").trim() || void 0;
   const fieldPath = String(input.fieldPath || "").trim();
   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();
+  const pageSize = typeof input.pageSize === "undefined" ? void 0 : Number(input.pageSize);
+  const showIndex = typeof input.showIndex === "undefined" ? void 0 : !!input.showIndex;
   if (!import_lodash.default.isUndefined(input.popup) && !import_lodash.default.isPlainObject(input.popup)) {
     (0, import_errors.throwBadRequest)(`flowSurfaces compose field #${index + 1} popup must be an object`);
   }
@@ -376,6 +401,14 @@ function normalizeComposeFieldSpec(input, index) {
     associationPathName: String(input.associationPathName || "").trim() || void 0,
     ...renderer ? { renderer } : {},
     ...semanticType ? { type: semanticType } : {},
+    ...fieldType ? { fieldType } : {},
+    ...!import_lodash.default.isUndefined(fields) ? { fields } : {},
+    ...!import_lodash.default.isUndefined(selectorFields) ? { selectorFields } : {},
+    ...titleField ? { titleField } : {},
+    ...openMode ? { openMode } : {},
+    ...popupSize ? { popupSize } : {},
+    ...!import_lodash.default.isUndefined(pageSize) && Number.isFinite(pageSize) ? { pageSize } : {},
+    ...!import_lodash.default.isUndefined(showIndex) ? { showIndex } : {},
     target: typeof input.target === "string" ? String(input.target || "").trim() || void 0 : void 0,
     settings: import_lodash.default.isPlainObject(input.settings) ? input.settings : {},
     popup: import_lodash.default.isPlainObject(input.popup) ? input.popup : void 0,
@@ -383,6 +416,16 @@ function normalizeComposeFieldSpec(input, index) {
     ...popupDefaultsMetadata ? { [import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY]: popupDefaultsMetadata } : {}
   };
 }
+function resolveRequestedFieldComponent(values) {
+  return void 0;
+}
+function resolveRequestedFieldUse(values) {
+  return resolveRequestedFieldComponent(values) || resolveRequestedFieldUseAlias(values);
+}
+function resolveRequestedFieldUseAlias(values) {
+  const legacyFieldUse = String((values == null ? void 0 : values.fieldUse) || "").trim();
+  return legacyFieldUse || void 0;
+}
 function normalizeComposeActionSpec(input, index) {
   if (typeof input === "string") {
     const type2 = String(input || "").trim();
@@ -595,13 +638,19 @@ function splitComposeFieldChanges(changes, wrapperUse) {
     "disabled",
     "maxCount",
     "pattern",
-    "titleField",
     "dataIndex",
     "editable",
     "labelWidth",
     "labelWrap",
     "name",
-    "fieldComponent",
+    "fieldType",
+    "fields",
+    "selectorFields",
+    "titleField",
+    "openMode",
+    "popupSize",
+    "pageSize",
+    "showIndex",
     ...wrapperUse === "TableColumnModel" ? ["title"] : []
   ]);
   const fieldChanges = import_lodash.default.pick(changes, [
@@ -805,6 +854,9 @@ function getFieldBindingDefaultProps(containerUse, fieldUse, field) {
   normalizeSimpleLayoutValue,
   normalizeSimpleResourceInit,
   normalizeStoredChartCardHeightMode,
+  resolveRequestedFieldComponent,
+  resolveRequestedFieldUse,
+  resolveRequestedFieldUseAlias,
   rethrowInlineConfigurationError,
   splitComposeFieldChanges,
   toFlowSurfaceBatchItemError

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

@@ -75,6 +75,9 @@ export declare class FlowSurfacesService {
     private analyzeCatalogTarget;
     private projectCatalogNode;
     private patchResolvedNodeConfigureOptions;
+    private buildRelationFieldTypeCandidates;
+    private collectRelationNestedFieldPaths;
+    private collectRelationSelectorFieldPaths;
     private projectCatalogItem;
     private buildCatalogBlockItem;
     private isCollectionBlockUse;
@@ -665,6 +668,7 @@ export declare class FlowSurfacesService {
     private configureTab;
     private configureTableBlock;
     private configureCalendarBlock;
+    private configureTreeBlock;
     private configureKanbanBlock;
     private configureFormBlock;
     private configureDetailsBlock;
@@ -687,6 +691,7 @@ export declare class FlowSurfacesService {
     private configureFieldNode;
     private normalizeFilterActionDefaultFilterValue;
     private configureActionNode;
+    private normalizeActionPanelActionChanges;
     private buildFieldCatalog;
     private getFieldMenuCatalogMode;
     private resolveRegisteredFieldBinding;
@@ -794,18 +799,29 @@ export declare class FlowSurfacesService {
     private buildAssociationTitleFieldUnavailableMessage;
     private resolveTitleFieldSyncDecision;
     private resolvePreferredFieldForCapability;
+    private supportsFieldTitleFieldProp;
+    private normalizeFieldPropsForUse;
     private ensureGridChild;
     private ensureTableActionsColumn;
     private ensurePopupSurface;
     private ensureFlowRoutePageSchemaShell;
     private removeFlowRoutePageSchemaShell;
     private normalizeDisplayFieldBinding;
+    private getCollectionFieldOrBadRequest;
+    private buildRelationTargetFieldInit;
+    private buildRelationTargetTableColumnNode;
+    private buildRelationTargetGridItemNode;
+    private replaceFieldSubModelArray;
+    private buildPopupSubTableActionsColumnNode;
+    private ensureFieldGridSubModel;
+    private applyResolvedRelationFieldType;
+    private applyRecordPickerFieldTypeSettings;
     private buildExactFieldSettingsInitPayload;
     private patchFieldSettingsInitExact;
     private inferFieldComponentFlowDomain;
     private resolveFieldComponentFieldSource;
     private assertSupportedFieldComponentUse;
-    private syncFieldComponentStepParams;
+    private syncFieldTypeStepParams;
     private rebuildFieldSubModelOnServer;
     private parseFieldPath;
     private loadResolvedNode;