@nocobase/flow-engine 2.0.0-alpha.2

package/lib/utils/schema-utils.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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 schema_utils_exports = {};
+__export(schema_utils_exports, {
+  compileUiSchema: () => compileUiSchema,
+  resolveStepUiSchema: () => resolveStepUiSchema,
+  resolveUiMode: () => resolveUiMode
+});
+module.exports = __toCommonJS(schema_utils_exports);
+var import_json_schema = require("@formily/json-schema");
+var import_flowContext = require("../flowContext");
+var import_setupRuntimeContextSteps = require("./setupRuntimeContextSteps");
+async function resolveUiSchema(uiSchema, ctx) {
+  if (!uiSchema) {
+    return {};
+  }
+  if (typeof uiSchema === "function") {
+    try {
+      const result = await uiSchema(ctx);
+      return result || {};
+    } catch (error) {
+      console.error("Error resolving uiSchema function:", error);
+      return {};
+    }
+  }
+  return uiSchema;
+}
+__name(resolveUiSchema, "resolveUiSchema");
+async function resolveUiMode(uiMode, ctx) {
+  if (!uiMode) {
+    return "dialog";
+  }
+  if (typeof uiMode === "function") {
+    try {
+      const result = await uiMode(ctx);
+      return result || "dialog";
+    } catch (error) {
+      console.error("Error resolving uiMode function:", error);
+      return "dialog";
+    }
+  }
+  return uiMode;
+}
+__name(resolveUiMode, "resolveUiMode");
+const compileCache = {};
+function compileUiSchema(scope, uiSchema, options = {}) {
+  const { noCache = false } = options;
+  const hasVariable = /* @__PURE__ */ __name((source) => {
+    const reg = /\{\{.*?\}\}/g;
+    return reg.test(source);
+  }, "hasVariable");
+  const compile = /* @__PURE__ */ __name((source) => {
+    let shouldCompile = false;
+    let cacheKey;
+    if (typeof source === "string" && source.startsWith("{{")) {
+      shouldCompile = true;
+      cacheKey = source;
+    }
+    if (source && typeof source === "object" && !Array.isArray(source)) {
+      try {
+        cacheKey = JSON.stringify(source);
+      } catch (e) {
+        console.warn("Failed to stringify:", e);
+        return source;
+      }
+      if (compileCache[cacheKey]) return compileCache[cacheKey];
+      shouldCompile = hasVariable(cacheKey);
+    }
+    if (Array.isArray(source)) {
+      try {
+        cacheKey = JSON.stringify(source);
+      } catch (e) {
+        console.warn("Failed to stringify:", e);
+        return source;
+      }
+      if (compileCache[cacheKey]) return compileCache[cacheKey];
+      shouldCompile = hasVariable(cacheKey);
+    }
+    if (shouldCompile) {
+      if (!cacheKey) {
+        try {
+          return import_json_schema.Schema.compile(source, scope);
+        } catch (error) {
+          console.warn("Failed to compile with Formily Schema.compile:", error);
+          return source;
+        }
+      }
+      try {
+        if (noCache) {
+          return import_json_schema.Schema.compile(source, scope);
+        }
+        compileCache[cacheKey] = compileCache[cacheKey] || import_json_schema.Schema.compile(source, scope);
+        return compileCache[cacheKey];
+      } catch (e) {
+        console.log("compileUiSchema error", source, e);
+        try {
+          return import_json_schema.Schema.compile(source, scope);
+        } catch (error) {
+          return source;
+        }
+      }
+    }
+    return source;
+  }, "compile");
+  return compile(uiSchema);
+}
+__name(compileUiSchema, "compileUiSchema");
+async function resolveStepUiSchema(model, flow, step) {
+  var _a, _b;
+  const flowRuntimeContext = new import_flowContext.FlowRuntimeContext(model, flow.key, "settings");
+  (0, import_setupRuntimeContextSteps.setupRuntimeContextSteps)(flowRuntimeContext, flow.steps, model, flow.key);
+  flowRuntimeContext.defineProperty("currentStep", { value: step });
+  let stepUiSchema = step.uiSchema;
+  if (step.use) {
+    try {
+      const action = (_b = (_a = model.flowEngine) == null ? void 0 : _a.getAction) == null ? void 0 : _b.call(_a, step.use);
+      if (action && action.uiSchema) {
+        stepUiSchema = stepUiSchema || action.uiSchema;
+      }
+    } catch (error) {
+      console.warn(`Failed to get action ${step.use}:`, error);
+    }
+  }
+  const resolvedStepUiSchema = await resolveUiSchema(stepUiSchema || {}, flowRuntimeContext);
+  if (Object.keys(resolvedStepUiSchema).length === 0) {
+    return null;
+  }
+  return resolvedStepUiSchema;
+}
+__name(resolveStepUiSchema, "resolveStepUiSchema");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileUiSchema,
+  resolveStepUiSchema,
+  resolveUiMode
+});

package/lib/utils/serverContextParams.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.
+ */
+import type { FlowContext } from '../flowContext';
+export type RecordRef = {
+    collection?: string;
+    id?: any;
+    filterByTk?: any;
+    dataSourceKey?: string;
+    fields?: string[];
+    appends?: string[];
+    record?: any;
+};
+export type BuildServerContextParamsInput = Record<string, any>;
+export type ServerContextParams = Record<string, NormalizedRecordParams>;
+export type NormalizedRecordParams = {
+    collection: string;
+    filterByTk: any;
+    dataSourceKey?: string;
+    fields?: string[];
+    appends?: string[];
+};
+export declare function buildServerContextParams(ctx: FlowContext, input?: BuildServerContextParamsInput): ServerContextParams | undefined;

package/lib/utils/serverContextParams.js

@@ -0,0 +1,106 @@
+/**
+ * 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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 serverContextParams_exports = {};
+__export(serverContextParams_exports, {
+  buildServerContextParams: () => buildServerContextParams
+});
+module.exports = __toCommonJS(serverContextParams_exports);
+function pickDefined(obj) {
+  const out = {};
+  Object.entries(obj || {}).forEach(([k, v]) => {
+    if (typeof v !== "undefined" && v !== null) out[k] = v;
+  });
+  return out;
+}
+__name(pickDefined, "pickDefined");
+function resolvePrimaryKey(ctx, dataSourceKey, collection) {
+  var _a, _b, _c, _d, _e;
+  try {
+    const ds = (_b = (_a = ctx.dataSourceManager) == null ? void 0 : _a.getDataSource) == null ? void 0 : _b.call(_a, dataSourceKey || "main");
+    const col = (_d = (_c = ds == null ? void 0 : ds.collectionManager) == null ? void 0 : _c.getCollection) == null ? void 0 : _d.call(_c, collection);
+    const pk = (_e = col == null ? void 0 : col.getPrimaryKey) == null ? void 0 : _e.call(col);
+    return pk || "id";
+  } catch (e) {
+    return "id";
+  }
+}
+__name(resolvePrimaryKey, "resolvePrimaryKey");
+function normalizeOne(ctx, ref) {
+  var _a, _b;
+  if (!ref) return void 0;
+  const dataSourceKey = ref.dataSourceKey || "main";
+  const collection = ref.collection || ((_a = ref.record) == null ? void 0 : _a.__collectionName);
+  if (!collection) return void 0;
+  const pk = resolvePrimaryKey(ctx, dataSourceKey, collection) || "id";
+  const filterByTk = typeof ref.filterByTk !== "undefined" ? ref.filterByTk : typeof ref.id !== "undefined" ? ref.id : (_b = ref.record) == null ? void 0 : _b[pk];
+  if (typeof filterByTk === "undefined") return void 0;
+  return pickDefined({
+    collection,
+    filterByTk,
+    dataSourceKey,
+    fields: ref.fields,
+    appends: ref.appends
+  });
+}
+__name(normalizeOne, "normalizeOne");
+function buildServerContextParams(ctx, input = {}) {
+  const isRecordRef = /* @__PURE__ */ __name((val) => {
+    if (!val || typeof val !== "object") return false;
+    return typeof val.collection === "string" && (typeof val.filterByTk !== "undefined" || typeof val.id !== "undefined" || val.record);
+  }, "isRecordRef");
+  const out = {};
+  const visit = /* @__PURE__ */ __name((src, path) => {
+    if (isRecordRef(src)) {
+      const norm = normalizeOne(ctx, src);
+      if (norm) {
+        const key = path.join(".");
+        out[key] = norm;
+      }
+      return;
+    }
+    if (Array.isArray(src)) {
+      for (let i = 0; i < src.length; i++) {
+        visit(src[i], [...path, String(i)]);
+      }
+      return;
+    }
+    if (src && typeof src === "object") {
+      for (const [k, v] of Object.entries(src)) {
+        visit(v, [...path, k]);
+      }
+      return;
+    }
+  }, "visit");
+  visit(input, []);
+  return Object.keys(out).length ? out : void 0;
+}
+__name(buildServerContextParams, "buildServerContextParams");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildServerContextParams
+});

package/lib/utils/setupRuntimeContextSteps.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 { FlowRuntimeContext } from '../flowContext';
+import { FlowModel } from '../models/flowModel';
+import { DefaultStructure, StepDefinition } from '../types';
+/**
+ * 为 FlowRuntimeContext 设置 steps 属性及其 meta 信息
+ * @param ctx FlowRuntimeContext 实例
+ * @param flowSteps 流定义
+ * @param model FlowModel 实例
+ * @param flowKey key
+ */
+export declare function setupRuntimeContextSteps(ctx: FlowRuntimeContext<any>, flowSteps: Record<string, StepDefinition<FlowModel<DefaultStructure>>>, model: FlowModel, flowKey: string): void;

package/lib/utils/setupRuntimeContextSteps.js

@@ -0,0 +1,88 @@
+/**
+ * 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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 setupRuntimeContextSteps_exports = {};
+__export(setupRuntimeContextSteps_exports, {
+  setupRuntimeContextSteps: () => setupRuntimeContextSteps
+});
+module.exports = __toCommonJS(setupRuntimeContextSteps_exports);
+function setupRuntimeContextSteps(ctx, flowSteps, model, flowKey) {
+  var _a;
+  const steps = {};
+  const stepsMetaProperties = {};
+  for (const stepKey in flowSteps) {
+    if (Object.prototype.hasOwnProperty.call(flowSteps, stepKey)) {
+      const flowStep = flowSteps[stepKey];
+      const paramsProperties = {};
+      if (flowStep.uiSchema && typeof flowStep.uiSchema === "object") {
+        for (const [paramKey, paramSchema] of Object.entries(flowStep.uiSchema)) {
+          if (paramSchema && typeof paramSchema === "object") {
+            const schema = paramSchema;
+            paramsProperties[paramKey] = {
+              type: schema.type || "any",
+              title: schema.title || ((_a = schema["x-decorator-props"]) == null ? void 0 : _a.label) || paramKey,
+              interface: schema["x-component"],
+              uiSchema: schema
+            };
+          }
+        }
+      }
+      const hasParams = Object.keys(paramsProperties).length > 0;
+      stepsMetaProperties[stepKey] = {
+        type: "object",
+        title: ctx.t(flowStep.title) || stepKey,
+        display: hasParams ? "default" : "none",
+        properties: hasParams ? {
+          params: {
+            type: "object",
+            title: "Parameters",
+            display: "flatten",
+            properties: paramsProperties
+          }
+        } : void 0
+      };
+      steps[stepKey] = {
+        get params() {
+          return model.getStepParams(flowKey, stepKey) || {};
+        },
+        get uiSchema() {
+          return flowStep.uiSchema;
+        },
+        result: void 0
+        // result 会在运行时被设置
+      };
+    }
+  }
+  ctx.defineProperty("steps", {
+    get: /* @__PURE__ */ __name(() => steps, "get")
+  });
+}
+__name(setupRuntimeContextSteps, "setupRuntimeContextSteps");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupRuntimeContextSteps
+});

package/lib/utils/translation.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 { TFuncKey, TOptions } from 'i18next';
+import type { FlowModel } from '../models';
+/**
+ * 获取带有 flow-engine 命名空间的翻译函数
+ * @param model FlowModel 实例
+ * @returns 翻译函数，自动使用 flow-engine 命名空间
+ */
+export declare function getT(model: FlowModel): (key: string, options?: any) => string;
+export declare function escapeT(text: TFuncKey | TFuncKey[], options?: TOptions): string;
+export { escapeT as tExpr };

package/lib/utils/translation.js

@@ -0,0 +1,58 @@
+/**
+ * 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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 translation_exports = {};
+__export(translation_exports, {
+  escapeT: () => escapeT,
+  getT: () => getT,
+  tExpr: () => escapeT
+});
+module.exports = __toCommonJS(translation_exports);
+var import_constants = require("./constants");
+function getT(model) {
+  var _a;
+  if ((_a = model.flowEngine) == null ? void 0 : _a.translate) {
+    return (key, options) => {
+      return model.flowEngine.translate(key, { ns: [import_constants.FLOW_ENGINE_NAMESPACE, "client"], nsMode: "fallback", ...options });
+    };
+  }
+  return (key) => key;
+}
+__name(getT, "getT");
+function escapeT(text, options) {
+  if (options) {
+    return `{{t(${JSON.stringify(text)}, ${JSON.stringify(options)})}}`;
+  }
+  return `{{t(${JSON.stringify(text)})}}`;
+}
+__name(escapeT, "escapeT");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  escapeT,
+  getT,
+  tExpr
+});

package/lib/utils/variablesParams.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 { FlowContext, PropertyMeta, PropertyMetaFactory } from '../flowContext';
+import type { JSONValue } from './params-resolvers';
+import type { Collection } from '../data-source';
+import { type RecordRef, type ServerContextParams } from '../utils/serverContextParams';
+export declare function inferRecordRef(ctx: FlowContext): RecordRef | undefined;
+export declare function inferParentRecordRef(ctx: FlowContext): RecordRef | undefined;
+export type RecordParamsBuilder = (ctx: FlowContext) => RecordRef | Promise<RecordRef> | undefined;
+/**
+ * Build a PropertyMeta for a record-like property with variablesParams included.
+ */
+export declare function buildRecordMeta(collectionAccessor: () => Collection | null, title?: string, paramsBuilder?: RecordParamsBuilder): Promise<PropertyMeta | null>;
+/**
+ * Convenience helper to create a PropertyMetaFactory for a record-like variable.
+ * It sets the factory.title so UI can display an immediate label before lazy resolution.
+ */
+export declare function createRecordMetaFactory(collectionAccessor: () => Collection | null, title: string, paramsBuilder?: RecordParamsBuilder): PropertyMetaFactory;
+/**
+ * Sugar for the most common case: a current record meta bound to FlowContext.
+ * - Title: t('Current record')
+ * - Params: inferRecordRef(ctx)
+ */
+export declare function createCurrentRecordMetaFactory(ctx: FlowContext, collectionAccessor: () => Collection | null): PropertyMetaFactory;
+/**
+ * Extract top-level ctx variable names used inside a JSON template.
+ * Supports dot and bracket notations, e.g. {{ ctx.record.id }}, {{ ctx['parentRecord'].name }}.
+ */
+export declare const extractUsedVariableNames: any;
+/**
+ * Extract used top-level ctx variables with their subpaths.
+ * Returns a map: varName -> string[] subPaths
+ * Examples:
+ *  - {{ ctx.user.id }}        => { user: ['id'] }
+ *  - {{ ctx['user'].roles[0].name }} => { user: ['roles[0].name'] }
+ *  - {{ ctx.view.record.id }} => { view: ['record.id'] }
+ *  - {{ ctx.twice(21) }}      => { twice: [''] } // method call -> empty subPath
+ */
+export declare const extractUsedVariablePaths: any;
+/**
+ * 根据模板中用到的 ctx 变量，收集并构建服务端解析所需的 contextParams。
+ * - 通过 FlowContext 的 PropertyMeta.buildVariablesParams 收集 RecordRef
+ * - 仅包含模板中实际使用到的顶层变量键，避免无谓膨胀
+ */
+export declare function collectContextParamsForTemplate(ctx: FlowContext, template: JSONValue): Promise<ServerContextParams | undefined>;

package/lib/utils/variablesParams.js

@@ -0,0 +1,150 @@
+/**
+ * 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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 variablesParams_exports = {};
+__export(variablesParams_exports, {
+  buildRecordMeta: () => buildRecordMeta,
+  collectContextParamsForTemplate: () => collectContextParamsForTemplate,
+  createCurrentRecordMetaFactory: () => createCurrentRecordMetaFactory,
+  createRecordMetaFactory: () => createRecordMetaFactory,
+  extractUsedVariableNames: () => extractUsedVariableNames,
+  extractUsedVariablePaths: () => extractUsedVariablePaths,
+  inferParentRecordRef: () => inferParentRecordRef,
+  inferRecordRef: () => inferRecordRef
+});
+module.exports = __toCommonJS(variablesParams_exports);
+var import_createCollectionContextMeta = require("./createCollectionContextMeta");
+var import_serverContextParams = require("../utils/serverContextParams");
+var import_client = require("@nocobase/utils/client");
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+__name(isObject, "isObject");
+function getResource(ctx) {
+  const r = ctx["resource"];
+  return isObject(r) ? r : void 0;
+}
+__name(getResource, "getResource");
+function getCollection(ctx) {
+  const c = ctx["collection"];
+  if (isObject(c)) {
+    const mc = c;
+    return { name: mc.name, dataSourceKey: mc.dataSourceKey };
+  }
+  return void 0;
+}
+__name(getCollection, "getCollection");
+function inferRecordRef(ctx) {
+  var _a, _b, _c;
+  const resource = getResource(ctx);
+  const collectionObj = getCollection(ctx);
+  const resourceName = (collectionObj == null ? void 0 : collectionObj.name) || ((_a = resource == null ? void 0 : resource.getResourceName) == null ? void 0 : _a.call(resource));
+  const dataSourceKey = (collectionObj == null ? void 0 : collectionObj.dataSourceKey) || ((_b = resource == null ? void 0 : resource.getDataSourceKey) == null ? void 0 : _b.call(resource));
+  const filterByTk = (_c = resource == null ? void 0 : resource.getFilterByTk) == null ? void 0 : _c.call(resource);
+  if (!resourceName || typeof filterByTk === "undefined" || filterByTk === null) return void 0;
+  const parts = String(resourceName).split(".");
+  const collection = parts[parts.length - 1];
+  return { collection, dataSourceKey, filterByTk };
+}
+__name(inferRecordRef, "inferRecordRef");
+function inferParentRecordRef(ctx) {
+  var _a, _b, _c, _d;
+  const resource = getResource(ctx);
+  const dataSourceKey = ((_a = getCollection(ctx)) == null ? void 0 : _a.dataSourceKey) || ((_b = resource == null ? void 0 : resource.getDataSourceKey) == null ? void 0 : _b.call(resource));
+  const rn = (_c = resource == null ? void 0 : resource.getResourceName) == null ? void 0 : _c.call(resource);
+  const sourceId = (_d = resource == null ? void 0 : resource.getSourceId) == null ? void 0 : _d.call(resource);
+  if (!rn || typeof sourceId === "undefined" || sourceId === null) return void 0;
+  const parts = String(rn).split(".");
+  if (parts.length < 2) return void 0;
+  return { collection: parts[0], dataSourceKey, filterByTk: sourceId };
+}
+__name(inferParentRecordRef, "inferParentRecordRef");
+async function buildRecordMeta(collectionAccessor, title, paramsBuilder) {
+  const base = await (0, import_createCollectionContextMeta.createCollectionContextMeta)(collectionAccessor, title)();
+  if (!base) return null;
+  return {
+    ...base,
+    buildVariablesParams: /* @__PURE__ */ __name((ctx) => paramsBuilder ? paramsBuilder(ctx) : inferRecordRef(ctx), "buildVariablesParams")
+  };
+}
+__name(buildRecordMeta, "buildRecordMeta");
+function createRecordMetaFactory(collectionAccessor, title, paramsBuilder) {
+  const factory = /* @__PURE__ */ __name(async () => buildRecordMeta(collectionAccessor, title, paramsBuilder), "factory");
+  factory.title = title;
+  return factory;
+}
+__name(createRecordMetaFactory, "createRecordMetaFactory");
+function createCurrentRecordMetaFactory(ctx, collectionAccessor) {
+  var _a;
+  const title = ((_a = ctx == null ? void 0 : ctx.t) == null ? void 0 : _a.call(ctx, "Current record")) || "Current record";
+  return createRecordMetaFactory(collectionAccessor, title, (c) => inferRecordRef(c));
+}
+__name(createCurrentRecordMetaFactory, "createCurrentRecordMetaFactory");
+const extractUsedVariableNames = import_client.extractUsedVariableNames;
+const extractUsedVariablePaths = import_client.extractUsedVariablePaths;
+async function collectContextParamsForTemplate(ctx, template) {
+  var _a;
+  try {
+    const usage = (0, import_client.extractUsedVariablePaths)(template) || {};
+    const varNames = Object.keys(usage);
+    if (!varNames.length) return void 0;
+    const input = {};
+    for (const key of varNames) {
+      const opt = (_a = ctx.getPropertyOptions) == null ? void 0 : _a.call(ctx, key);
+      const meta = opt == null ? void 0 : opt.meta;
+      if (!meta) continue;
+      let built;
+      try {
+        const resolvedMeta = typeof meta === "function" ? await meta() : meta;
+        const builder = resolvedMeta == null ? void 0 : resolvedMeta.buildVariablesParams;
+        if (typeof builder === "function") {
+          built = await builder(ctx);
+        }
+      } catch (err) {
+        continue;
+      }
+      if (built) {
+        input[key] = built;
+      }
+    }
+    return (0, import_serverContextParams.buildServerContextParams)(ctx, input);
+  } catch (_) {
+    return void 0;
+  }
+}
+__name(collectContextParamsForTemplate, "collectContextParamsForTemplate");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildRecordMeta,
+  collectContextParamsForTemplate,
+  createCurrentRecordMetaFactory,
+  createRecordMetaFactory,
+  extractUsedVariableNames,
+  extractUsedVariablePaths,
+  inferParentRecordRef,
+  inferRecordRef
+});