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

package/dist/server/flow-surfaces/catalog-smart.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 { FlowSurfaceCatalogExpand, FlowSurfaceCatalogScenario, FlowSurfaceCatalogSection } from './types';
+import type { FlowSurfaceCatalogAnalyzeTargetInput, FlowSurfaceCatalogAnalyzeTargetResult, FlowSurfaceCatalogExpandFlags, FlowSurfaceCatalogScenarioInput, FlowSurfaceCatalogSelectedSectionsInput } from './catalog-smart.types';
+export * from './catalog-smart.types';
+export { buildCatalogItemOptionalFields, buildFieldCatalogLightCandidate, expandFieldCatalogCandidate, projectCatalogItem, projectCatalogNode, } from './catalog-smart.projector';
+export declare function normalizeCatalogSections(actionName: string, input: any): FlowSurfaceCatalogSection[];
+export declare function normalizeCatalogExpand(actionName: string, input: any): FlowSurfaceCatalogExpand[];
+export declare function buildCatalogExpandFlags(expands: Iterable<FlowSurfaceCatalogExpand>): FlowSurfaceCatalogExpandFlags;
+export declare function scenario(input: FlowSurfaceCatalogScenarioInput): FlowSurfaceCatalogScenario;
+export declare function selectedSections(input: FlowSurfaceCatalogSelectedSectionsInput): FlowSurfaceCatalogSection[];
+export declare function analyzeCatalogTarget(input: FlowSurfaceCatalogAnalyzeTargetInput): FlowSurfaceCatalogAnalyzeTargetResult;

package/dist/server/flow-surfaces/catalog-smart.js

@@ -0,0 +1,239 @@
+/**
+ * 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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 catalog_smart_exports = {};
+__export(catalog_smart_exports, {
+  analyzeCatalogTarget: () => analyzeCatalogTarget,
+  buildCatalogExpandFlags: () => buildCatalogExpandFlags,
+  buildCatalogItemOptionalFields: () => import_catalog_smart.buildCatalogItemOptionalFields,
+  buildFieldCatalogLightCandidate: () => import_catalog_smart.buildFieldCatalogLightCandidate,
+  expandFieldCatalogCandidate: () => import_catalog_smart.expandFieldCatalogCandidate,
+  normalizeCatalogExpand: () => normalizeCatalogExpand,
+  normalizeCatalogSections: () => normalizeCatalogSections,
+  projectCatalogItem: () => import_catalog_smart.projectCatalogItem,
+  projectCatalogNode: () => import_catalog_smart.projectCatalogNode,
+  scenario: () => scenario,
+  selectedSections: () => selectedSections
+});
+module.exports = __toCommonJS(catalog_smart_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_action_scope = require("./action-scope");
+var import_errors = require("./errors");
+var import_field_semantics = require("./field-semantics");
+__reExport(catalog_smart_exports, require("./catalog-smart.types"), module.exports);
+var import_catalog_smart = require("./catalog-smart.projector");
+const FLOW_SURFACE_CATALOG_SECTION_SET = /* @__PURE__ */ new Set([
+  "blocks",
+  "fields",
+  "actions",
+  "recordActions",
+  "node"
+]);
+const FLOW_SURFACE_CATALOG_EXPAND_SET = /* @__PURE__ */ new Set([
+  "item.configureOptions",
+  "item.contracts",
+  "item.allowedContainerUses",
+  "node.contracts"
+]);
+function resolveCatalogPopupScenario(input) {
+  if (!(input == null ? void 0 : input.isPopupSurface)) {
+    return void 0;
+  }
+  return {
+    kind: input.popupKind || "plainPopup",
+    scene: input.scene || "generic",
+    hasCurrentRecord: !!input.hasCurrentRecord,
+    hasAssociationContext: !!input.hasAssociationContext
+  };
+}
+function resolveCatalogFieldContainerScenario(input) {
+  const kind = (0, import_field_semantics.normalizeFieldContainerKind)(input.ownerUse || void 0);
+  if (!kind) {
+    return void 0;
+  }
+  if (kind === "filter-form") {
+    return {
+      kind,
+      targetMode: (input.filterFormTargetCount || 0) > 1 ? "multiple" : "single"
+    };
+  }
+  return { kind };
+}
+function resolveCatalogActionContainerScenario(input) {
+  const ownerUse = input.ownerUse || void 0;
+  const scope = (0, import_action_scope.getActionContainerScope)(ownerUse);
+  if (!scope) {
+    return void 0;
+  }
+  return import_lodash.default.pickBy(
+    {
+      scope,
+      ownerUse,
+      recordActionContainerUse: input.recordActionContainerUse || void 0
+    },
+    (value) => !import_lodash.default.isUndefined(value)
+  );
+}
+function normalizeCatalogSections(actionName, input) {
+  if (import_lodash.default.isUndefined(input)) {
+    return [];
+  }
+  if (!Array.isArray(input)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} sections must be an array`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return input.map((value, index) => {
+    const normalized = String(value || "").trim();
+    if (!FLOW_SURFACE_CATALOG_SECTION_SET.has(normalized)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} sections[${index}] '${String(value || "")}' is not supported`);
+    }
+    if (seen.has(normalized)) {
+      return null;
+    }
+    seen.add(normalized);
+    return normalized;
+  }).filter(Boolean);
+}
+function normalizeCatalogExpand(actionName, input) {
+  if (import_lodash.default.isUndefined(input)) {
+    return [];
+  }
+  if (!Array.isArray(input)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} expand must be an array`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return input.map((value, index) => {
+    const normalized = String(value || "").trim();
+    if (!FLOW_SURFACE_CATALOG_EXPAND_SET.has(normalized)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} expand[${index}] '${String(value || "")}' is not supported`);
+    }
+    if (seen.has(normalized)) {
+      return null;
+    }
+    seen.add(normalized);
+    return normalized;
+  }).filter(Boolean);
+}
+function buildCatalogExpandFlags(expands) {
+  const expandSet = new Set(expands);
+  return {
+    includeItemConfigureOptions: expandSet.has("item.configureOptions"),
+    includeItemContracts: expandSet.has("item.contracts"),
+    includeItemAllowedContainerUses: expandSet.has("item.allowedContainerUses"),
+    includeNodeContracts: expandSet.has("node.contracts")
+  };
+}
+function scenario(input) {
+  return import_lodash.default.pickBy(
+    {
+      surfaceKind: input.surfaceKind,
+      popup: input.popup,
+      fieldContainer: input.fieldContainer,
+      actionContainer: input.actionContainer
+    },
+    (value) => !import_lodash.default.isUndefined(value)
+  );
+}
+function selectedSections(input) {
+  if (!import_lodash.default.isUndefined(input.requestedSections)) {
+    return input.requestedSections;
+  }
+  if (!input.hasTarget) {
+    return ["blocks", "actions", "recordActions"];
+  }
+  const sections = [];
+  if (input.hasBlockSurface) {
+    sections.push("blocks");
+  }
+  if (input.hasFieldContainer) {
+    sections.push("fields");
+  }
+  if (input.hasActionContainer) {
+    sections.push("actions");
+  }
+  if (input.hasRecordActions) {
+    sections.push("recordActions");
+  }
+  sections.push("node");
+  return sections;
+}
+function analyzeCatalogTarget(input) {
+  var _a, _b, _c;
+  const recordActionContainerUse = input.recordActionContainerUse || null;
+  const popup = resolveCatalogPopupScenario(input.popupProfile);
+  const fieldContainer = resolveCatalogFieldContainerScenario({
+    ownerUse: (_a = input.fieldContainer) == null ? void 0 : _a.ownerUse,
+    filterFormTargetCount: input.filterFormTargetCount
+  });
+  const actionContainer = resolveCatalogActionContainerScenario({
+    ownerUse: (_b = input.actionContainer) == null ? void 0 : _b.ownerUse,
+    recordActionContainerUse
+  });
+  const hasRecordActions = import_lodash.default.isBoolean(input.hasRecordActions) ? input.hasRecordActions : !!recordActionContainerUse || !input.hasTarget;
+  return {
+    scenario: scenario({
+      surfaceKind: input.surfaceKind || ((_c = input.resolved) == null ? void 0 : _c.kind) || "global",
+      popup,
+      fieldContainer,
+      actionContainer
+    }),
+    selectedSections: selectedSections({
+      requestedSections: input.requestedSections,
+      hasTarget: input.hasTarget,
+      hasBlockSurface: input.hasBlockSurface,
+      hasFieldContainer: !!fieldContainer,
+      hasActionContainer: !!actionContainer,
+      hasRecordActions
+    }),
+    recordActionContainerUse
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyzeCatalogTarget,
+  buildCatalogExpandFlags,
+  buildCatalogItemOptionalFields,
+  buildFieldCatalogLightCandidate,
+  expandFieldCatalogCandidate,
+  normalizeCatalogExpand,
+  normalizeCatalogSections,
+  projectCatalogItem,
+  projectCatalogNode,
+  scenario,
+  selectedSections,
+  ...require("./catalog-smart.types")
+});

package/dist/server/flow-surfaces/catalog-smart.projector.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 { FlowSurfaceCatalogExpandFlags, FlowSurfaceCatalogItemOptionalFieldsOptions, FlowSurfaceCatalogItemOptionalFieldsProviders, FlowSurfaceCatalogNodeProjectInput, FlowSurfaceCatalogNodeProjectResult, FlowSurfaceCatalogProjectItemOptions, FlowSurfaceCatalogProjectableItem, FlowSurfaceCatalogProjectedItem, FlowSurfaceFieldCatalogProjectableItem, FlowSurfaceFieldCatalogLightCandidate } from './catalog-smart.types';
+export declare function buildCatalogItemOptionalFields(use: string | undefined, options: FlowSurfaceCatalogItemOptionalFieldsOptions, providers: FlowSurfaceCatalogItemOptionalFieldsProviders): _.Dictionary<any>;
+export declare function buildFieldCatalogLightCandidate(item: FlowSurfaceFieldCatalogProjectableItem): FlowSurfaceFieldCatalogLightCandidate;
+export declare function projectCatalogItem(item: FlowSurfaceCatalogProjectableItem, expand: FlowSurfaceCatalogExpandFlags, options: FlowSurfaceCatalogProjectItemOptions): FlowSurfaceCatalogProjectedItem;
+export declare function expandFieldCatalogCandidate(item: FlowSurfaceFieldCatalogProjectableItem, expand: FlowSurfaceCatalogExpandFlags, options: FlowSurfaceCatalogProjectItemOptions): FlowSurfaceCatalogProjectedItem;
+export declare function projectCatalogNode(node: any, resolved: FlowSurfaceCatalogNodeProjectInput['resolved'], expand: FlowSurfaceCatalogExpandFlags, options: FlowSurfaceCatalogNodeProjectInput['options']): FlowSurfaceCatalogNodeProjectResult;

package/dist/server/flow-surfaces/catalog-smart.projector.js

@@ -0,0 +1,157 @@
+/**
+ * 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 catalog_smart_projector_exports = {};
+__export(catalog_smart_projector_exports, {
+  buildCatalogItemOptionalFields: () => buildCatalogItemOptionalFields,
+  buildFieldCatalogLightCandidate: () => buildFieldCatalogLightCandidate,
+  expandFieldCatalogCandidate: () => expandFieldCatalogCandidate,
+  projectCatalogItem: () => projectCatalogItem,
+  projectCatalogNode: () => projectCatalogNode
+});
+module.exports = __toCommonJS(catalog_smart_projector_exports);
+var import_lodash = __toESM(require("lodash"));
+const LIGHT_CATALOG_ITEM_KEYS = [
+  "key",
+  "label",
+  "use",
+  "kind",
+  "scope",
+  "scene",
+  "fieldUse",
+  "wrapperUse",
+  "associationPathName",
+  "defaultTargetUid",
+  "targetBlockUid",
+  "requiredInitParams",
+  "createSupported",
+  "renderer",
+  "type"
+];
+function pickLightCatalogItem(item) {
+  var _a;
+  const projected = import_lodash.default.pick(item, LIGHT_CATALOG_ITEM_KEYS);
+  if ((_a = item.resourceBindings) == null ? void 0 : _a.length) {
+    projected.resourceBindings = item.resourceBindings;
+  }
+  return import_lodash.default.pickBy(projected, (value) => !import_lodash.default.isUndefined(value));
+}
+function createNodeContractResolver(item, options) {
+  let loaded = false;
+  let cached;
+  return () => {
+    if (!loaded) {
+      cached = options.getNodeContract(item.use);
+      loaded = true;
+    }
+    return cached;
+  };
+}
+function buildCatalogItemOptionalFields(use, options = {}, providers) {
+  const projected = {};
+  if (options.includeContracts) {
+    const contract = providers.getNodeContract(use);
+    projected.editableDomains = providers.getEditableDomains(use);
+    projected.settingsSchema = providers.getSettingsSchema(use);
+    projected.settingsContract = contract == null ? void 0 : contract.domains;
+    projected.eventCapabilities = contract == null ? void 0 : contract.eventCapabilities;
+    projected.layoutCapabilities = contract == null ? void 0 : contract.layoutCapabilities;
+  }
+  if (options.includeConfigureOptions) {
+    projected.configureOptions = providers.getConfigureOptions(use);
+  }
+  return import_lodash.default.pickBy(projected, (value) => !import_lodash.default.isUndefined(value));
+}
+function buildFieldCatalogLightCandidate(item) {
+  return pickLightCatalogItem({
+    ...item,
+    kind: "field"
+  });
+}
+function projectCatalogItem(item, expand, options) {
+  var _a, _b, _c, _d;
+  const projected = pickLightCatalogItem(item);
+  if (expand.includeItemAllowedContainerUses && ((_a = item.allowedContainerUses) == null ? void 0 : _a.length)) {
+    projected.allowedContainerUses = item.allowedContainerUses;
+  }
+  if (expand.includeItemConfigureOptions) {
+    projected.configureOptions = !import_lodash.default.isUndefined(item.configureOptions) ? item.configureOptions : options.getConfigureOptions(item);
+  }
+  if (expand.includeItemContracts) {
+    const resolveContract = createNodeContractResolver(item, options);
+    projected.editableDomains = !import_lodash.default.isUndefined(item.editableDomains) ? item.editableDomains : options.getEditableDomains(item.use);
+    projected.settingsSchema = !import_lodash.default.isUndefined(item.settingsSchema) ? item.settingsSchema : options.getSettingsSchema(item.use);
+    projected.settingsContract = !import_lodash.default.isUndefined(item.settingsContract) ? item.settingsContract : (_b = resolveContract()) == null ? void 0 : _b.domains;
+    projected.eventCapabilities = !import_lodash.default.isUndefined(item.eventCapabilities) ? item.eventCapabilities : (_c = resolveContract()) == null ? void 0 : _c.eventCapabilities;
+    projected.layoutCapabilities = !import_lodash.default.isUndefined(item.layoutCapabilities) ? item.layoutCapabilities : (_d = resolveContract()) == null ? void 0 : _d.layoutCapabilities;
+  }
+  return import_lodash.default.pickBy(projected, (value) => !import_lodash.default.isUndefined(value));
+}
+function expandFieldCatalogCandidate(item, expand, options) {
+  return projectCatalogItem(buildFieldCatalogLightCandidate(item), expand, options);
+}
+function projectCatalogNode(node, resolved, expand, options) {
+  var _a, _b, _c, _d, _e;
+  const input = {
+    node,
+    resolved: resolved || null,
+    expand,
+    options
+  };
+  const projected = {
+    editableDomains: input.options.getEditableDomains((_a = input.node) == null ? void 0 : _a.use),
+    configureOptions: input.options.getConfigureOptionsForResolvedNode({
+      kind: (_b = input.resolved) == null ? void 0 : _b.kind,
+      use: (_c = input.node) == null ? void 0 : _c.use
+    })
+  };
+  if (input.expand.includeNodeContracts) {
+    const contract = input.options.getNodeContract((_d = input.node) == null ? void 0 : _d.use);
+    projected.settingsSchema = input.options.getSettingsSchema((_e = input.node) == null ? void 0 : _e.use);
+    projected.settingsContract = contract == null ? void 0 : contract.domains;
+    projected.eventCapabilities = contract == null ? void 0 : contract.eventCapabilities;
+    projected.layoutCapabilities = contract == null ? void 0 : contract.layoutCapabilities;
+  }
+  return projected;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildCatalogItemOptionalFields,
+  buildFieldCatalogLightCandidate,
+  expandFieldCatalogCandidate,
+  projectCatalogItem,
+  projectCatalogNode
+});

package/dist/server/flow-surfaces/catalog-smart.types.d.ts

@@ -0,0 +1,99 @@
+/**
+ * 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 { FlowSurfaceCatalogActionContainerScenario, FlowSurfaceCatalogFieldContainerScenario, FlowSurfaceCatalogItem, FlowSurfaceCatalogNodeInfo, FlowSurfaceCatalogPopupScenario, FlowSurfaceCatalogScenario, FlowSurfaceCatalogSection, FlowSurfaceNodeContract, FlowSurfaceNodeDomain, FlowSurfaceResolvedTarget } from './types';
+export type FlowSurfaceCatalogExpandFlags = {
+    includeItemConfigureOptions: boolean;
+    includeItemContracts: boolean;
+    includeItemAllowedContainerUses: boolean;
+    includeNodeContracts: boolean;
+};
+export type FlowSurfaceCatalogPopupLike = {
+    isPopupSurface?: boolean;
+    popupKind?: FlowSurfaceCatalogPopupScenario['kind'] | null;
+    scene?: FlowSurfaceCatalogPopupScenario['scene'];
+    hasCurrentRecord?: boolean;
+    hasAssociationContext?: boolean;
+};
+export type FlowSurfaceCatalogFieldContainerLike = {
+    ownerUse?: string | null;
+};
+export type FlowSurfaceCatalogActionContainerLike = {
+    ownerUse?: string | null;
+};
+export type FlowSurfaceCatalogAnalyzeTargetInput = {
+    hasTarget: boolean;
+    hasBlockSurface: boolean;
+    resolved?: Pick<FlowSurfaceResolvedTarget, 'kind'> | null;
+    surfaceKind?: FlowSurfaceCatalogScenario['surfaceKind'];
+    requestedSections?: FlowSurfaceCatalogSection[];
+    popupProfile?: FlowSurfaceCatalogPopupLike | null;
+    fieldContainer?: FlowSurfaceCatalogFieldContainerLike | null;
+    filterFormTargetCount?: number;
+    actionContainer?: FlowSurfaceCatalogActionContainerLike | null;
+    recordActionContainerUse?: string | null;
+    hasRecordActions?: boolean;
+};
+export type FlowSurfaceCatalogAnalyzeTargetResult = {
+    scenario: FlowSurfaceCatalogScenario;
+    selectedSections: FlowSurfaceCatalogSection[];
+    recordActionContainerUse: string | null;
+};
+export type FlowSurfaceCatalogScenarioInput = {
+    surfaceKind: FlowSurfaceCatalogScenario['surfaceKind'];
+    popup?: FlowSurfaceCatalogPopupScenario;
+    fieldContainer?: FlowSurfaceCatalogFieldContainerScenario;
+    actionContainer?: FlowSurfaceCatalogActionContainerScenario;
+};
+export type FlowSurfaceCatalogSelectedSectionsInput = {
+    requestedSections?: FlowSurfaceCatalogSection[];
+    hasTarget: boolean;
+    hasBlockSurface: boolean;
+    hasFieldContainer: boolean;
+    hasActionContainer: boolean;
+    hasRecordActions: boolean;
+};
+export type FlowSurfaceCatalogProjectedItem = FlowSurfaceCatalogItem & {
+    renderer?: string;
+    type?: string;
+};
+export type FlowSurfaceCatalogProjectableItem = Pick<FlowSurfaceCatalogItem, 'key' | 'label' | 'use' | 'kind'> & Partial<FlowSurfaceCatalogItem> & Record<string, any>;
+export type FlowSurfaceFieldCatalogProjectableItem = Pick<FlowSurfaceCatalogItem, 'key' | 'label' | 'use'> & Partial<Omit<FlowSurfaceCatalogItem, 'kind'>> & Record<string, any>;
+export type FlowSurfaceFieldCatalogLightCandidate = FlowSurfaceCatalogProjectedItem;
+export type FlowSurfaceCatalogProjectItemOptions = {
+    getEditableDomains: (use?: string) => FlowSurfaceNodeDomain[];
+    getConfigureOptions: (item?: Pick<FlowSurfaceCatalogItem, 'kind' | 'use'> | null) => Record<string, any>;
+    getSettingsSchema: (use?: string) => Record<string, any>;
+    getNodeContract: (use?: string) => FlowSurfaceNodeContract;
+};
+export type FlowSurfaceCatalogItemOptionalFieldsOptions = {
+    includeConfigureOptions?: boolean;
+    includeContracts?: boolean;
+};
+export type FlowSurfaceCatalogItemOptionalFieldsProviders = {
+    getEditableDomains: (use?: string) => FlowSurfaceNodeDomain[];
+    getConfigureOptions: (use?: string) => Record<string, any>;
+    getSettingsSchema: (use?: string) => Record<string, any>;
+    getNodeContract: (use?: string) => FlowSurfaceNodeContract;
+};
+export type FlowSurfaceCatalogNodeProjectOptions = {
+    getEditableDomains: (use?: string) => FlowSurfaceNodeDomain[];
+    getConfigureOptionsForResolvedNode: (input: {
+        kind?: string;
+        use?: string;
+    }) => Record<string, any>;
+    getSettingsSchema: (use?: string) => Record<string, any>;
+    getNodeContract: (use?: string) => FlowSurfaceNodeContract;
+};
+export type FlowSurfaceCatalogNodeProjectInput = {
+    node: any;
+    resolved: Pick<FlowSurfaceResolvedTarget, 'kind'> | null;
+    expand: FlowSurfaceCatalogExpandFlags;
+    options: FlowSurfaceCatalogNodeProjectOptions;
+};
+export type FlowSurfaceCatalogNodeProjectResult = FlowSurfaceCatalogNodeInfo;

package/dist/server/flow-surfaces/catalog-smart.types.js

@@ -0,0 +1,24 @@
+/**
+ * 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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var catalog_smart_types_exports = {};
+module.exports = __toCommonJS(catalog_smart_types_exports);

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

@@ -0,0 +1,79 @@
+/**
+ * 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 { FlowSurfaceActionScope, FlowSurfaceCatalogItem, FlowSurfaceLayoutCapabilities, FlowSurfaceNodeContract, FlowSurfaceNodeDomain } from './types';
+export declare const READONLY_NODE_CONTRACT: FlowSurfaceNodeContract;
+export declare function getSupportedFieldComponentUseSet(input: {
+    containerUse: string;
+    field?: any;
+    enabledPackages?: ReadonlySet<string>;
+    dataSourceKey?: string;
+    getCollection?: (dataSourceKey: string, collectionName: string) => any;
+}): Set<string>;
+export declare function resolveSupportedFieldCapability(input: {
+    containerUse: string;
+    field?: any;
+    requestedFieldUse?: string;
+    requestedFieldUseMode?: 'fieldUse' | 'fieldType';
+    requestedWrapperUse?: string;
+    allowUnresolvedFieldUse?: boolean;
+    requestedRenderer?: string;
+    requestedType?: string;
+    enabledPackages?: ReadonlySet<string>;
+    dataSourceKey?: string;
+    getCollection?: (dataSourceKey: string, collectionName: string) => any;
+}): {
+    wrapperUse: any;
+    fieldUse: any;
+    inferredFieldUse: any;
+    standaloneUse: string;
+    renderer: any;
+} | {
+    wrapperUse: string;
+    fieldUse: any;
+    inferredFieldUse: any;
+    standaloneUse: any;
+    renderer: string;
+};
+export declare function getAvailableActionCatalogItems(containerUse?: string, scope?: FlowSurfaceActionScope, enabledPackages?: ReadonlySet<string>): FlowSurfaceCatalogItem[];
+export declare const blockCatalog: FlowSurfaceCatalogItem[];
+export declare function getAvailableBlockCatalogItems(containerUse?: string, enabledPackages?: ReadonlySet<string>): FlowSurfaceCatalogItem[];
+export declare const actionCatalog: FlowSurfaceCatalogItem[];
+export declare const ACTION_PUBLIC_KEYS: string[];
+export declare const SERVICE_SUPPORTED_FLOW_SURFACE_BLOCK_KEYS: string[];
+export declare const BLOCK_CATALOG_BY_KEY: Map<string, FlowSurfaceCatalogItem>;
+export declare const BLOCK_CATALOG_BY_USE: Map<string, FlowSurfaceCatalogItem>;
+export declare const ACTION_CATALOG_BY_KEY: Map<string, FlowSurfaceCatalogItem[]>;
+export declare const ACTION_CATALOG_BY_USE: Map<string, FlowSurfaceCatalogItem[]>;
+export declare const BLOCK_KEY_BY_USE: Map<string, string>;
+export declare const ACTION_KEY_BY_USE: Map<string, string>;
+export declare function isCatalogItemAvailable(item: Pick<FlowSurfaceCatalogItem, 'kind' | 'use'>, enabledPackages?: ReadonlySet<string>): boolean;
+export declare function filterAvailableCatalogItems<T extends Pick<FlowSurfaceCatalogItem, 'kind' | 'use'>>(items: T[], enabledPackages?: ReadonlySet<string>): T[];
+export declare function resolveSupportedBlockCatalogItem(input: {
+    type?: string;
+    use?: string;
+    containerUse?: string;
+}, options?: {
+    context?: string;
+    enabledPackages?: ReadonlySet<string>;
+    requireCreateSupported?: boolean;
+    skipContainerValidation?: boolean;
+}): FlowSurfaceCatalogItem;
+export declare function resolveSupportedActionCatalogItem(input: {
+    type?: string;
+    use?: string;
+    containerUse?: string;
+}, options?: {
+    context?: string;
+    enabledPackages?: ReadonlySet<string>;
+    requireCreateSupported?: boolean;
+}): FlowSurfaceCatalogItem;
+export declare function getNodeContract(use?: string): FlowSurfaceNodeContract;
+export declare function getEditableDomainsForUse(use?: string): FlowSurfaceNodeDomain[];
+export declare function getSettingsSchemaForUse(use?: string): Record<string, any>;
+export declare function getLayoutCapabilitiesForUse(use?: string): FlowSurfaceLayoutCapabilities | undefined;