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

package/dist/server/flow-surfaces/planning/step-link.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 { isFlowSurfacePlanStepValue } from '../reference-guards';
+import type { FlowSurfacePlanStepLink } from '../types';
+export declare const isFlowSurfacePlanStepLink: typeof isFlowSurfacePlanStepValue;
+export declare function normalizeFlowSurfacePlanStepLink(actionName: string, input: any, fieldName: string): FlowSurfacePlanStepLink;
+export declare function assertFlowSurfaceKnownPlanStepLink(actionName: string, stepLink: FlowSurfacePlanStepLink, fieldName: string, knownStepIds?: Set<string>): void;
+export declare function replaceFlowSurfacePlanStepLinks(actionName: string, input: any, path: string, knownStepIds?: Set<string>, knownRuntimeKeys?: Set<string>): any;

package/dist/server/flow-surfaces/planning/step-link.js

@@ -0,0 +1,104 @@
+/**
+ * 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 step_link_exports = {};
+__export(step_link_exports, {
+  assertFlowSurfaceKnownPlanStepLink: () => assertFlowSurfaceKnownPlanStepLink,
+  isFlowSurfacePlanStepLink: () => isFlowSurfacePlanStepLink,
+  normalizeFlowSurfacePlanStepLink: () => normalizeFlowSurfacePlanStepLink,
+  replaceFlowSurfacePlanStepLinks: () => replaceFlowSurfacePlanStepLinks
+});
+module.exports = __toCommonJS(step_link_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("../errors");
+var import_reference_guards = require("../reference-guards");
+var import_created_keys = require("./created-keys");
+const isFlowSurfacePlanStepLink = import_reference_guards.isFlowSurfacePlanStepValue;
+function normalizeFlowSurfacePlanStepLink(actionName, input, fieldName) {
+  return (0, import_reference_guards.normalizeFlowSurfacePlanStepValue)(actionName, input, fieldName);
+}
+function assertFlowSurfaceKnownPlanStepLink(actionName, stepLink, fieldName, knownStepIds) {
+  if (!knownStepIds || knownStepIds.has(stepLink.step)) {
+    return;
+  }
+  (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${fieldName}.step '${stepLink.step}' is not a previous step id`);
+}
+function replaceFlowSurfacePlanStepLinks(actionName, input, path, knownStepIds, knownRuntimeKeys) {
+  if (Array.isArray(input)) {
+    return input.map(
+      (item, index) => replaceFlowSurfacePlanStepLinks(actionName, item, `${path}[${index}]`, knownStepIds, knownRuntimeKeys)
+    );
+  }
+  if (!import_lodash.default.isPlainObject(input)) {
+    return input;
+  }
+  (0, import_reference_guards.assertNoFlowSurfaceLegacyRef)(input, {
+    actionName,
+    path,
+    dollarRefAllowed: "{ step, path }",
+    refAllowed: "{ key } or { step, path }"
+  });
+  if (isFlowSurfacePlanStepLink(input)) {
+    const stepLink = normalizeFlowSurfacePlanStepLink(actionName, input, path);
+    assertFlowSurfaceKnownPlanStepLink(actionName, stepLink, path, knownStepIds);
+    return stepLink;
+  }
+  if ((0, import_created_keys.isFlowSurfacePureKeyObject)(input)) {
+    const runtimeKey = String(input.key || "").trim();
+    if (!runtimeKey) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.key cannot be empty`);
+    }
+    if (!(knownRuntimeKeys == null ? void 0 : knownRuntimeKeys.has(runtimeKey))) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.key '${runtimeKey}' is not defined`);
+    }
+    return {
+      key: runtimeKey
+    };
+  }
+  return Object.fromEntries(
+    Object.entries(input).map(([key, value]) => [
+      key,
+      replaceFlowSurfacePlanStepLinks(actionName, value, `${path}.${key}`, knownStepIds, knownRuntimeKeys)
+    ])
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertFlowSurfaceKnownPlanStepLink,
+  isFlowSurfacePlanStepLink,
+  normalizeFlowSurfacePlanStepLink,
+  replaceFlowSurfacePlanStepLinks
+});

package/dist/server/flow-surfaces/planning/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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 { FlowSurfaceMutateOp, FlowSurfacePlanStepLink, FlowSurfacePlanStepAction, FlowSurfaceReadLocator, FlowSurfaceReadTarget, FlowSurfaceResolvedTarget, FlowSurfaceSurfaceSelector } from '../types';
+import type { FlowSurfaceCreatedKeySpec } from './created-keys';
+export type FlowSurfaceResolvedKey = {
+    key: string;
+    uid: string;
+    source: 'declared' | 'request' | 'system';
+    kind: string;
+    locator: FlowSurfaceReadLocator;
+    rebind?: boolean;
+    reboundFromUid?: string;
+};
+export type FlowSurfaceResolvedSelectorSummary = {
+    uid?: string;
+    kind?: string;
+    key?: string;
+    step?: string;
+    path?: string;
+    source: FlowSurfaceResolvedKey['source'] | 'step' | 'created';
+};
+export type FlowSurfacePlanSurfaceContext = {
+    surfaceSelector?: FlowSurfaceSurfaceSelector;
+    surfaceTarget?: FlowSurfaceReadLocator;
+    surfaceResolved?: FlowSurfaceResolvedTarget;
+    rawTree?: any;
+    publicTree?: any;
+    publicNodeMap: Record<string, any>;
+    targetSummary: FlowSurfaceReadTarget | null;
+    fingerprint: string | null;
+    uidSet: Set<string>;
+    keyMap: Map<string, FlowSurfaceResolvedKey>;
+    requestKeyMap: Map<string, FlowSurfaceResolvedKey>;
+};
+export type FlowSurfaceCompiledPlanStepSelectorLink = FlowSurfacePlanStepLink & {
+    summary: FlowSurfaceResolvedSelectorSummary;
+};
+export type FlowSurfaceCompiledPlanStep = {
+    index: number;
+    id?: string;
+    action: FlowSurfacePlanStepAction;
+    payload: Record<string, any>;
+    executionPayload?: Record<string, any>;
+    resolvedSelectors: Partial<Record<'target' | 'source', FlowSurfaceResolvedSelectorSummary>>;
+    usedKeys: FlowSurfaceResolvedKey[];
+    usedStepLinks: FlowSurfaceCompiledPlanStepSelectorLink[];
+    createdKeys: FlowSurfaceCreatedKeySpec[];
+    mutateOp?: FlowSurfaceMutateOp;
+};

package/dist/server/flow-surfaces/planning/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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/server/flow-surfaces/public-data-surface-default-filter.d.ts

@@ -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.
+ */
+export declare const FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPES: Set<string>;
+export declare const FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPE_LABEL = "table/list/gridCard/calendar/kanban";
+export declare function isFlowSurfacePublicDataSurfaceBlockType(blockType?: string): boolean;
+export declare function normalizeFlowSurfacePublicBlockDefaultFilter(actionName: string, defaultFilter: any, options: {
+    blockType?: string;
+    template?: unknown;
+    path?: string;
+}): any;
+export declare function assertFlowSurfaceConcreteDefaultFilterItem(actionName: string, defaultFilter: any, options?: {
+    path?: string;
+}): void;
+export declare function backfillFlowSurfaceDefaultFilterSetting(settings: any, defaultFilter: any): any;
+export declare function backfillFlowSurfaceFilterActionDefaultFilter<T extends {
+    type?: string;
+    settings?: Record<string, any>;
+}>(actions: T[], defaultFilter: any): T[];

package/dist/server/flow-surfaces/public-data-surface-default-filter.js

@@ -0,0 +1,152 @@
+/**
+ * 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_data_surface_default_filter_exports = {};
+__export(public_data_surface_default_filter_exports, {
+  FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPES: () => FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPES,
+  FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPE_LABEL: () => FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPE_LABEL,
+  assertFlowSurfaceConcreteDefaultFilterItem: () => assertFlowSurfaceConcreteDefaultFilterItem,
+  backfillFlowSurfaceDefaultFilterSetting: () => backfillFlowSurfaceDefaultFilterSetting,
+  backfillFlowSurfaceFilterActionDefaultFilter: () => backfillFlowSurfaceFilterActionDefaultFilter,
+  isFlowSurfacePublicDataSurfaceBlockType: () => isFlowSurfacePublicDataSurfaceBlockType,
+  normalizeFlowSurfacePublicBlockDefaultFilter: () => normalizeFlowSurfacePublicBlockDefaultFilter
+});
+module.exports = __toCommonJS(public_data_surface_default_filter_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("./errors");
+var import_filter_group = require("./filter-group");
+const FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPES = /* @__PURE__ */ new Set([
+  "table",
+  "list",
+  "gridCard",
+  "calendar",
+  "kanban"
+]);
+const FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPE_LABEL = "table/list/gridCard/calendar/kanban";
+function isFlowSurfacePublicDataSurfaceBlockType(blockType) {
+  return FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPES.has(String(blockType || "").trim());
+}
+function normalizeFlowSurfacePublicBlockDefaultFilter(actionName, defaultFilter, options) {
+  if (import_lodash.default.isUndefined(defaultFilter)) {
+    return void 0;
+  }
+  const fieldPath = buildFlowSurfaceDefaultFilterFieldPath(actionName, options.path);
+  if (!isFlowSurfacePublicDataSurfaceBlockType(options.blockType) || !import_lodash.default.isUndefined(options.template)) {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${actionName} ${fieldPath} is only supported on direct ${FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPE_LABEL} blocks`
+    );
+  }
+  const normalized = (0, import_filter_group.normalizeFlowSurfaceFilterGroupValue)(
+    defaultFilter,
+    `flowSurfaces ${actionName} ${fieldPath} expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`
+  );
+  return normalized;
+}
+function assertFlowSurfaceConcreteDefaultFilterItem(actionName, defaultFilter, options = {}) {
+  const fieldPath = buildFlowSurfaceDefaultFilterFieldPath(actionName, options.path);
+  if (!hasConcreteFlowSurfaceFilterItem(defaultFilter)) {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${actionName} ${fieldPath} must include at least one concrete filter item; empty defaultFilter groups such as {}, null, or { logic, items: [] } are not allowed`
+    );
+  }
+}
+function buildFlowSurfaceDefaultFilterFieldPath(actionName, path) {
+  if (!path) {
+    return "defaultFilter";
+  }
+  const prefix = `flowSurfaces ${actionName} `;
+  const normalizedPath = path.startsWith(prefix) ? path.slice(prefix.length) : path;
+  return normalizedPath.endsWith(".defaultFilter") ? normalizedPath : `${normalizedPath}.defaultFilter`;
+}
+function hasConcreteFlowSurfaceFilterItem(filter) {
+  if (!import_lodash.default.isPlainObject(filter) || !Array.isArray(filter.items)) {
+    return false;
+  }
+  return filter.items.some((item) => {
+    if (import_lodash.default.isPlainObject(item) && "logic" in item && "items" in item) {
+      return hasConcreteFlowSurfaceFilterItem(item);
+    }
+    return import_lodash.default.isPlainObject(item) && typeof item.path === "string" && typeof item.operator === "string";
+  });
+}
+function backfillFlowSurfaceDefaultFilterSetting(settings, defaultFilter) {
+  if (import_lodash.default.isUndefined(defaultFilter)) {
+    return settings;
+  }
+  if (import_lodash.default.isUndefined(settings)) {
+    return {
+      defaultFilter: import_lodash.default.cloneDeep(defaultFilter)
+    };
+  }
+  if (!import_lodash.default.isPlainObject(settings)) {
+    return settings;
+  }
+  if (Object.prototype.hasOwnProperty.call(settings, "defaultFilter")) {
+    return settings;
+  }
+  return {
+    ...import_lodash.default.cloneDeep(settings),
+    defaultFilter: import_lodash.default.cloneDeep(defaultFilter)
+  };
+}
+function backfillFlowSurfaceFilterActionDefaultFilter(actions, defaultFilter) {
+  if (import_lodash.default.isUndefined(defaultFilter)) {
+    return actions;
+  }
+  return actions.map((action) => {
+    if (String((action == null ? void 0 : action.type) || "").trim() !== "filter") {
+      return action;
+    }
+    const settings = backfillFlowSurfaceDefaultFilterSetting(action.settings, defaultFilter);
+    if (settings === action.settings) {
+      return action;
+    }
+    return {
+      ...action,
+      settings
+    };
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPES,
+  FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPE_LABEL,
+  assertFlowSurfaceConcreteDefaultFilterItem,
+  backfillFlowSurfaceDefaultFilterSetting,
+  backfillFlowSurfaceFilterActionDefaultFilter,
+  isFlowSurfacePublicDataSurfaceBlockType,
+  normalizeFlowSurfacePublicBlockDefaultFilter
+});

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

@@ -0,0 +1,20 @@
+/**
+ * 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_REACTION_UNSUPPORTED_TARGET_KIND = "FLOW_SURFACE_REACTION_UNSUPPORTED_TARGET_KIND";
+export declare const FLOW_SURFACE_REACTION_AMBIGUOUS_SCENE = "FLOW_SURFACE_REACTION_AMBIGUOUS_SCENE";
+export declare const FLOW_SURFACE_REACTION_UNSUPPORTED_ACTION_FOR_SCENE = "FLOW_SURFACE_REACTION_UNSUPPORTED_ACTION_FOR_SCENE";
+export declare const FLOW_SURFACE_REACTION_UNKNOWN_TARGET_KEY = "FLOW_SURFACE_REACTION_UNKNOWN_TARGET_KEY";
+export declare const FLOW_SURFACE_REACTION_DUPLICATE_SLOT = "FLOW_SURFACE_REACTION_DUPLICATE_SLOT";
+export declare const FLOW_SURFACE_REACTION_INVALID_CONDITION_PATH = "FLOW_SURFACE_REACTION_INVALID_CONDITION_PATH";
+export declare const FLOW_SURFACE_REACTION_INVALID_CONDITION_OPERATOR = "FLOW_SURFACE_REACTION_INVALID_CONDITION_OPERATOR";
+export declare const FLOW_SURFACE_REACTION_INVALID_VALUE_SOURCE = "FLOW_SURFACE_REACTION_INVALID_VALUE_SOURCE";
+export declare const FLOW_SURFACE_REACTION_INVALID_VALUE_PATH = "FLOW_SURFACE_REACTION_INVALID_VALUE_PATH";
+export declare const FLOW_SURFACE_REACTION_INVALID_TARGET_FIELD = "FLOW_SURFACE_REACTION_INVALID_TARGET_FIELD";
+export declare const FLOW_SURFACE_REACTION_FINGERPRINT_CONFLICT = "FLOW_SURFACE_REACTION_FINGERPRINT_CONFLICT";
+export declare const FLOW_SURFACE_REACTION_FORM_ONLY = "FLOW_SURFACE_REACTION_FORM_ONLY";

package/dist/server/flow-surfaces/reaction/errors.js

@@ -0,0 +1,69 @@
+/**
+ * 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 __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  FLOW_SURFACE_REACTION_AMBIGUOUS_SCENE: () => FLOW_SURFACE_REACTION_AMBIGUOUS_SCENE,
+  FLOW_SURFACE_REACTION_DUPLICATE_SLOT: () => FLOW_SURFACE_REACTION_DUPLICATE_SLOT,
+  FLOW_SURFACE_REACTION_FINGERPRINT_CONFLICT: () => FLOW_SURFACE_REACTION_FINGERPRINT_CONFLICT,
+  FLOW_SURFACE_REACTION_FORM_ONLY: () => FLOW_SURFACE_REACTION_FORM_ONLY,
+  FLOW_SURFACE_REACTION_INVALID_CONDITION_OPERATOR: () => FLOW_SURFACE_REACTION_INVALID_CONDITION_OPERATOR,
+  FLOW_SURFACE_REACTION_INVALID_CONDITION_PATH: () => FLOW_SURFACE_REACTION_INVALID_CONDITION_PATH,
+  FLOW_SURFACE_REACTION_INVALID_TARGET_FIELD: () => FLOW_SURFACE_REACTION_INVALID_TARGET_FIELD,
+  FLOW_SURFACE_REACTION_INVALID_VALUE_PATH: () => FLOW_SURFACE_REACTION_INVALID_VALUE_PATH,
+  FLOW_SURFACE_REACTION_INVALID_VALUE_SOURCE: () => FLOW_SURFACE_REACTION_INVALID_VALUE_SOURCE,
+  FLOW_SURFACE_REACTION_UNKNOWN_TARGET_KEY: () => FLOW_SURFACE_REACTION_UNKNOWN_TARGET_KEY,
+  FLOW_SURFACE_REACTION_UNSUPPORTED_ACTION_FOR_SCENE: () => FLOW_SURFACE_REACTION_UNSUPPORTED_ACTION_FOR_SCENE,
+  FLOW_SURFACE_REACTION_UNSUPPORTED_TARGET_KIND: () => FLOW_SURFACE_REACTION_UNSUPPORTED_TARGET_KIND
+});
+module.exports = __toCommonJS(errors_exports);
+const FLOW_SURFACE_REACTION_UNSUPPORTED_TARGET_KIND = "FLOW_SURFACE_REACTION_UNSUPPORTED_TARGET_KIND";
+const FLOW_SURFACE_REACTION_AMBIGUOUS_SCENE = "FLOW_SURFACE_REACTION_AMBIGUOUS_SCENE";
+const FLOW_SURFACE_REACTION_UNSUPPORTED_ACTION_FOR_SCENE = "FLOW_SURFACE_REACTION_UNSUPPORTED_ACTION_FOR_SCENE";
+const FLOW_SURFACE_REACTION_UNKNOWN_TARGET_KEY = "FLOW_SURFACE_REACTION_UNKNOWN_TARGET_KEY";
+const FLOW_SURFACE_REACTION_DUPLICATE_SLOT = "FLOW_SURFACE_REACTION_DUPLICATE_SLOT";
+const FLOW_SURFACE_REACTION_INVALID_CONDITION_PATH = "FLOW_SURFACE_REACTION_INVALID_CONDITION_PATH";
+const FLOW_SURFACE_REACTION_INVALID_CONDITION_OPERATOR = "FLOW_SURFACE_REACTION_INVALID_CONDITION_OPERATOR";
+const FLOW_SURFACE_REACTION_INVALID_VALUE_SOURCE = "FLOW_SURFACE_REACTION_INVALID_VALUE_SOURCE";
+const FLOW_SURFACE_REACTION_INVALID_VALUE_PATH = "FLOW_SURFACE_REACTION_INVALID_VALUE_PATH";
+const FLOW_SURFACE_REACTION_INVALID_TARGET_FIELD = "FLOW_SURFACE_REACTION_INVALID_TARGET_FIELD";
+const FLOW_SURFACE_REACTION_FINGERPRINT_CONFLICT = "FLOW_SURFACE_REACTION_FINGERPRINT_CONFLICT";
+const FLOW_SURFACE_REACTION_FORM_ONLY = "FLOW_SURFACE_REACTION_FORM_ONLY";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FLOW_SURFACE_REACTION_AMBIGUOUS_SCENE,
+  FLOW_SURFACE_REACTION_DUPLICATE_SLOT,
+  FLOW_SURFACE_REACTION_FINGERPRINT_CONFLICT,
+  FLOW_SURFACE_REACTION_FORM_ONLY,
+  FLOW_SURFACE_REACTION_INVALID_CONDITION_OPERATOR,
+  FLOW_SURFACE_REACTION_INVALID_CONDITION_PATH,
+  FLOW_SURFACE_REACTION_INVALID_TARGET_FIELD,
+  FLOW_SURFACE_REACTION_INVALID_VALUE_PATH,
+  FLOW_SURFACE_REACTION_INVALID_VALUE_SOURCE,
+  FLOW_SURFACE_REACTION_UNKNOWN_TARGET_KEY,
+  FLOW_SURFACE_REACTION_UNSUPPORTED_ACTION_FOR_SCENE,
+  FLOW_SURFACE_REACTION_UNSUPPORTED_TARGET_KIND
+});

package/dist/server/flow-surfaces/reaction/field-value.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { FlowSurfaceFieldValueRule, FlowSurfaceReactionTargetSummary, FlowSurfaceReactionWriteResult } from './types';
+export type FlowSurfaceFieldValueTarget = FlowSurfaceReactionTargetSummary & {
+    use?: string | null;
+    collection?: any;
+};
+export type FlowSurfaceFieldValueCompileResult = FlowSurfaceReactionWriteResult<FlowSurfaceFieldValueRule> & {
+    updateAssociationValues: string[];
+};
+export declare function isFieldValueTargetUseSupported(use?: string | null): boolean;
+export declare function assertFieldValueTargetSupported(target: FlowSurfaceFieldValueTarget): void;
+export declare function normalizeFieldValueRules(rules: FlowSurfaceFieldValueRule[] | undefined): FlowSurfaceFieldValueRule[];
+export declare function compileFieldValueRulesToCanonical(rules: FlowSurfaceFieldValueRule[] | undefined): {
+    key: string;
+    enable: boolean;
+    targetPath: string;
+    mode: string;
+    condition: import("./types").FlowSurfaceReactionFilter;
+    value: any;
+}[];
+export declare function collectUpdateAssociationValuesFromFieldValueRules(items: Array<{
+    targetPath?: string;
+} | any>, rootCollection: any): string[];
+export declare function buildFieldValueWriteResult(params: {
+    target: FlowSurfaceFieldValueTarget;
+    rules: FlowSurfaceFieldValueRule[] | undefined;
+}): FlowSurfaceFieldValueCompileResult;