@nocobase/flow-engine 2.0.0-alpha.7 → 2.0.0-alpha.71

package/lib/utils/createCollectionContextMeta.js

@@ -32,7 +32,7 @@ __export(createCollectionContextMeta_exports, {
 module.exports = __toCommonJS(createCollectionContextMeta_exports);
 const RELATION_FIELD_TYPES = ["belongsTo", "hasOne", "hasMany", "belongsToMany", "belongsToArray"];
 const NUMERIC_FIELD_TYPES = ["integer", "float", "double", "decimal"];
-function createFieldMetadata(field) {
+function createFieldMetadata(field, includeNonFilterable) {
   const baseProperties = createMetaBaseProperties(field);
   if (field.isAssociationField()) {
     const targetCollection = field.targetCollection;
@@ -49,7 +49,9 @@ function createFieldMetadata(field) {
       properties: /* @__PURE__ */ __name(async () => {
         const subProperties = {};
         targetCollection.fields.forEach((subField) => {
-          subProperties[subField.name] = createFieldMetadata(subField);
+          if (includeNonFilterable || subField.filterable) {
+            subProperties[subField.name] = createFieldMetadata(subField, includeNonFilterable);
+          }
         });
         return subProperties;
       }, "properties")
@@ -85,11 +87,12 @@ function createMetaBaseProperties(field) {
   return {
     title: field.title || field.name,
     interface: field.interface,
+    options: field.options,
     uiSchema: field.uiSchema || {}
   };
 }
 __name(createMetaBaseProperties, "createMetaBaseProperties");
-function createCollectionContextMeta(collectionOrFactory, title) {
+function createCollectionContextMeta(collectionOrFactory, title, includeNonFilterable) {
   const metaFn = /* @__PURE__ */ __name(async () => {
     const collection = typeof collectionOrFactory === "function" ? collectionOrFactory() : collectionOrFactory;
     if (!collection) {
@@ -101,7 +104,9 @@ function createCollectionContextMeta(collectionOrFactory, title) {
       properties: /* @__PURE__ */ __name(async () => {
         const properties = {};
         collection.fields.forEach((field) => {
-          properties[field.name] = createFieldMetadata(field);
+          if (includeNonFilterable || field.filterable) {
+            properties[field.name] = createFieldMetadata(field, includeNonFilterable);
+          }
         });
         return properties;
       }, "properties")

package/lib/utils/createEphemeralContext.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 { FlowContext } from '../flowContext';
+import type { ActionDefinition } from '../types';
+type ContextDefsLike<TCtx extends FlowContext> = Partial<Pick<ActionDefinition<any, TCtx>, 'defineProperties' | 'defineMethods'>> | null | undefined;
+export declare function createEphemeralContext<TCtx extends FlowContext>(parent: TCtx, contextDefs?: ContextDefsLike<TCtx>): Promise<TCtx>;
+export {};

package/lib/utils/createEphemeralContext.js

@@ -0,0 +1,140 @@
+/**
+ * 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 createEphemeralContext_exports = {};
+__export(createEphemeralContext_exports, {
+  createEphemeralContext: () => createEphemeralContext
+});
+module.exports = __toCommonJS(createEphemeralContext_exports);
+var import_flowContext = require("../flowContext");
+async function createEphemeralContext(parent, contextDefs) {
+  if (contextDefs == null || !contextDefs.defineProperties && !contextDefs.defineMethods) {
+    return parent;
+  }
+  const scoped = new import_flowContext.FlowContext();
+  scoped.addDelegate(parent);
+  const scopedProxy = scoped.createProxy();
+  const scopedObj = scopedProxy;
+  const parentObj = parent;
+  const getFromParent = /* @__PURE__ */ __name((key) => {
+    const val = Reflect.get(parentObj, key, parentObj);
+    return typeof val === "function" ? val.bind(parent) : val;
+  }, "getFromParent");
+  const hasInScopedOrParent = /* @__PURE__ */ __name((key) => key === "defineProperty" || key === "defineMethod" || Reflect.has(scopedObj, key) || Reflect.has(parentObj, key), "hasInScopedOrParent");
+  const injectionProxy = new Proxy(scopedProxy, {
+    get(_t, key, receiver) {
+      if (typeof key === "string") {
+        if (key === "defineProperty") {
+          return (propKey, options) => scoped.defineProperty(propKey, options);
+        }
+        if (key === "defineMethod") {
+          return (name, fn, des) => scoped.defineMethod(name, fn, des);
+        }
+        if (Reflect.has(scopedObj, key)) {
+          return Reflect.get(scopedObj, key, receiver);
+        }
+        return getFromParent(key);
+      }
+      return Reflect.get(scopedObj, key, receiver);
+    },
+    set(_t, key, value) {
+      return Reflect.set(parentObj, key, value);
+    },
+    has(_t, key) {
+      return hasInScopedOrParent(key);
+    },
+    getOwnPropertyDescriptor(_t, key) {
+      return Object.getOwnPropertyDescriptor(scopedObj, key) || Object.getOwnPropertyDescriptor(parentObj, key);
+    }
+  });
+  if (contextDefs) {
+    const defs = Array.isArray(contextDefs) ? contextDefs : [contextDefs];
+    for (const defLike of defs) {
+      if (!defLike) continue;
+      const dp = defLike.defineProperties;
+      if (dp) {
+        const raw = typeof dp === "function" ? await dp(injectionProxy) : dp;
+        if (!raw || typeof raw !== "object") {
+          throw new TypeError("defineProperties must return an object of PropertyOptions");
+        }
+        const propsDef = raw;
+        for (const [key, options] of Object.entries(propsDef)) {
+          if (!options || typeof options !== "object") {
+            throw new TypeError(`defineProperties['${key}'] must be a PropertyOptions object`);
+          }
+          scoped.defineProperty(key, options);
+        }
+      }
+      const dm = defLike.defineMethods;
+      if (dm) {
+        const raw = typeof dm === "function" ? await dm(injectionProxy) : dm;
+        if (!raw || typeof raw !== "object") {
+          throw new TypeError("defineMethods must return an object of functions");
+        }
+        const methodsDef = raw;
+        for (const [key, fn] of Object.entries(methodsDef)) {
+          if (typeof fn !== "function") {
+            throw new TypeError(`defineMethods['${key}'] must be a function`);
+          }
+          scoped.defineMethod(key, fn);
+        }
+      }
+    }
+  }
+  const outerProxy = new Proxy(scopedProxy, {
+    get(_t, key, receiver) {
+      if (typeof key === "string") {
+        if (key === "defineProperty") {
+          return (propKey, options) => parent.defineProperty(propKey, options);
+        }
+        if (key === "defineMethod") {
+          return (name, fn, des) => parent.defineMethod(name, fn, des);
+        }
+        if (Reflect.has(scopedObj, key)) {
+          return Reflect.get(scopedObj, key, receiver);
+        }
+        return getFromParent(key);
+      }
+      return Reflect.get(scopedObj, key, receiver);
+    },
+    set(_t, key, value) {
+      return Reflect.set(parentObj, key, value);
+    },
+    has(_t, key) {
+      return hasInScopedOrParent(key);
+    },
+    getOwnPropertyDescriptor(_t, key) {
+      return Object.getOwnPropertyDescriptor(scopedObj, key) || Object.getOwnPropertyDescriptor(parentObj, key);
+    }
+  });
+  return outerProxy;
+}
+__name(createEphemeralContext, "createEphemeralContext");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEphemeralContext
+});

package/lib/utils/flows.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 { FlowDefinition } from '../FlowDefinition';
+export declare const isBeforeRenderFlow: (flow: FlowDefinition) => boolean;

package/lib/{runjs-context/snippets/global/console-log-ctx.snippet.js → utils/flows.js}

@@ -11,6 +11,7 @@ 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 });
@@ -24,18 +25,24 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var console_log_ctx_snippet_exports = {};
-__export(console_log_ctx_snippet_exports, {
-  default: () => console_log_ctx_snippet_default
+var flows_exports = {};
+__export(flows_exports, {
+  isBeforeRenderFlow: () => isBeforeRenderFlow
+});
+module.exports = __toCommonJS(flows_exports);
+const isBeforeRenderFlow = /* @__PURE__ */ __name((flow) => {
+  if (typeof flow.on === "string") {
+    return flow.on === "beforeRender";
+  }
+  if (typeof flow.on === "object") {
+    return flow.on.eventName === "beforeRender";
+  }
+  if (!flow.on && flow.manual !== true) {
+    return true;
+  }
+  return false;
+}, "isBeforeRenderFlow");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isBeforeRenderFlow
 });
-module.exports = __toCommonJS(console_log_ctx_snippet_exports);
-var console_log_ctx_snippet_default = {
-  contexts: ["*"],
-  prefix: "sn-log-ctx",
-  label: "Log ctx",
-  description: "Log the whole ctx object to console",
-  content: `
-console.log('ctx =>', ctx);
-ctx.message?.success?.(ctx.t('ctx printed'));
-`
-};

package/lib/utils/index.d.ts

@@ -12,11 +12,17 @@ export { FlowExitException } from './exceptions';
 export { defineAction } from './flow-definitions';
 export { isInheritedFrom } from './inheritance';
 export { resolveCreateModelOptions, resolveDefaultParams, resolveExpressions } from './params-resolvers';
-export { compileUiSchema, resolveStepUiSchema, resolveUiMode } from './schema-utils';
+export { compileUiSchema, resolveStepUiSchema, resolveUiMode, shouldHideStepInSettings } from './schema-utils';
 export { setupRuntimeContextSteps } from './setupRuntimeContextSteps';
 export { createCollectionContextMeta } from './createCollectionContextMeta';
-export { buildRecordMeta, collectContextParamsForTemplate, createCurrentRecordMetaFactory, createRecordMetaFactory, extractUsedVariableNames, extractUsedVariablePaths, inferParentRecordRef, inferRecordRef, type RecordParamsBuilder, } from './variablesParams';
+export { createAssociationAwareObjectMetaFactory, createAssociationSubpathResolver } from './associationObjectVariable';
+export { buildRecordMeta, collectContextParamsForTemplate, createCurrentRecordMetaFactory, createRecordResolveOnServerWithLocal, createRecordMetaFactory, extractUsedVariableNames, extractUsedVariablePaths, inferRecordRef, type RecordParamsBuilder, } from './variablesParams';
 export { extractPropertyPath, formatPathToVariable, isVariableExpression } from './context';
 export { clearAutoFlowError, getAutoFlowError, setAutoFlowError, type AutoFlowError } from './autoFlowError';
 export { parsePathnameToViewParams, type ViewParam } from './parsePathnameToViewParams';
-export { createSafeDocument, createSafeWindow } from './safeGlobals';
+export { createSafeDocument, createSafeWindow, createSafeNavigator } from './safeGlobals';
+export { prepareRunJsCode, preprocessRunJsTemplates } from './runjsTemplateCompat';
+export { createEphemeralContext } from './createEphemeralContext';
+export { pruneFilter } from './pruneFilter';
+export { isBeforeRenderFlow } from './flows';
+export { resolveModuleUrl, isCssFile } from './resolveModuleUrl';

package/lib/utils/index.js

@@ -35,10 +35,15 @@ __export(utils_exports, {
   clearAutoFlowError: () => import_autoFlowError.clearAutoFlowError,
   collectContextParamsForTemplate: () => import_variablesParams.collectContextParamsForTemplate,
   compileUiSchema: () => import_schema_utils.compileUiSchema,
+  createAssociationAwareObjectMetaFactory: () => import_associationObjectVariable.createAssociationAwareObjectMetaFactory,
+  createAssociationSubpathResolver: () => import_associationObjectVariable.createAssociationSubpathResolver,
   createCollectionContextMeta: () => import_createCollectionContextMeta.createCollectionContextMeta,
   createCurrentRecordMetaFactory: () => import_variablesParams.createCurrentRecordMetaFactory,
+  createEphemeralContext: () => import_createEphemeralContext.createEphemeralContext,
   createRecordMetaFactory: () => import_variablesParams.createRecordMetaFactory,
+  createRecordResolveOnServerWithLocal: () => import_variablesParams.createRecordResolveOnServerWithLocal,
   createSafeDocument: () => import_safeGlobals.createSafeDocument,
+  createSafeNavigator: () => import_safeGlobals.createSafeNavigator,
   createSafeWindow: () => import_safeGlobals.createSafeWindow,
   defineAction: () => import_flow_definitions.defineAction,
   escapeT: () => import_translation.escapeT,
@@ -48,18 +53,24 @@ __export(utils_exports, {
   formatPathToVariable: () => import_context.formatPathToVariable,
   getAutoFlowError: () => import_autoFlowError.getAutoFlowError,
   getT: () => import_translation.getT,
-  inferParentRecordRef: () => import_variablesParams.inferParentRecordRef,
   inferRecordRef: () => import_variablesParams.inferRecordRef,
+  isBeforeRenderFlow: () => import_flows.isBeforeRenderFlow,
+  isCssFile: () => import_resolveModuleUrl.isCssFile,
   isInheritedFrom: () => import_inheritance.isInheritedFrom,
   isVariableExpression: () => import_context.isVariableExpression,
   parsePathnameToViewParams: () => import_parsePathnameToViewParams.parsePathnameToViewParams,
+  prepareRunJsCode: () => import_runjsTemplateCompat.prepareRunJsCode,
+  preprocessRunJsTemplates: () => import_runjsTemplateCompat.preprocessRunJsTemplates,
+  pruneFilter: () => import_pruneFilter.pruneFilter,
   resolveCreateModelOptions: () => import_params_resolvers.resolveCreateModelOptions,
   resolveDefaultParams: () => import_params_resolvers.resolveDefaultParams,
   resolveExpressions: () => import_params_resolvers.resolveExpressions,
+  resolveModuleUrl: () => import_resolveModuleUrl.resolveModuleUrl,
   resolveStepUiSchema: () => import_schema_utils.resolveStepUiSchema,
   resolveUiMode: () => import_schema_utils.resolveUiMode,
   setAutoFlowError: () => import_autoFlowError.setAutoFlowError,
   setupRuntimeContextSteps: () => import_setupRuntimeContextSteps.setupRuntimeContextSteps,
+  shouldHideStepInSettings: () => import_schema_utils.shouldHideStepInSettings,
   tExpr: () => import_translation.tExpr
 });
 module.exports = __toCommonJS(utils_exports);
@@ -72,11 +83,17 @@ var import_params_resolvers = require("./params-resolvers");
 var import_schema_utils = require("./schema-utils");
 var import_setupRuntimeContextSteps = require("./setupRuntimeContextSteps");
 var import_createCollectionContextMeta = require("./createCollectionContextMeta");
+var import_associationObjectVariable = require("./associationObjectVariable");
 var import_variablesParams = require("./variablesParams");
 var import_context = require("./context");
 var import_autoFlowError = require("./autoFlowError");
 var import_parsePathnameToViewParams = require("./parsePathnameToViewParams");
 var import_safeGlobals = require("./safeGlobals");
+var import_runjsTemplateCompat = require("./runjsTemplateCompat");
+var import_createEphemeralContext = require("./createEphemeralContext");
+var import_pruneFilter = require("./pruneFilter");
+var import_flows = require("./flows");
+var import_resolveModuleUrl = require("./resolveModuleUrl");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BLOCK_GROUP_CONFIGS,
@@ -88,10 +105,15 @@ var import_safeGlobals = require("./safeGlobals");
   clearAutoFlowError,
   collectContextParamsForTemplate,
   compileUiSchema,
+  createAssociationAwareObjectMetaFactory,
+  createAssociationSubpathResolver,
   createCollectionContextMeta,
   createCurrentRecordMetaFactory,
+  createEphemeralContext,
   createRecordMetaFactory,
+  createRecordResolveOnServerWithLocal,
   createSafeDocument,
+  createSafeNavigator,
   createSafeWindow,
   defineAction,
   escapeT,
@@ -101,17 +123,23 @@ var import_safeGlobals = require("./safeGlobals");
   formatPathToVariable,
   getAutoFlowError,
   getT,
-  inferParentRecordRef,
   inferRecordRef,
+  isBeforeRenderFlow,
+  isCssFile,
   isInheritedFrom,
   isVariableExpression,
   parsePathnameToViewParams,
+  prepareRunJsCode,
+  preprocessRunJsTemplates,
+  pruneFilter,
   resolveCreateModelOptions,
   resolveDefaultParams,
   resolveExpressions,
+  resolveModuleUrl,
   resolveStepUiSchema,
   resolveUiMode,
   setAutoFlowError,
   setupRuntimeContextSteps,
+  shouldHideStepInSettings,
   tExpr
 });

package/lib/utils/jsxTransform.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.
+ */
+/**
+ * Lightweight JSX -> JS compiler for RunJS user code.
+ * - Uses sucrase via dynamic import (lazy; avoids static cycles and cost when not needed)
+ * - Maps JSX to ctx.React.createElement / ctx.React.Fragment so no global React is required
+ * - If sucrase is unavailable or transform throws, returns original code as graceful fallback
+ */
+export declare function compileRunJs(code: string): Promise<string>;

package/lib/utils/jsxTransform.js

@@ -0,0 +1,68 @@
+/**
+ * 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 __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 __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 jsxTransform_exports = {};
+__export(jsxTransform_exports, {
+  compileRunJs: () => compileRunJs
+});
+module.exports = __toCommonJS(jsxTransform_exports);
+async function compileRunJs(code) {
+  var _a;
+  const maybeJSX = /<[A-Za-z]|<\//.test(code);
+  if (!maybeJSX) return code;
+  try {
+    const mod = await import("sucrase");
+    const transform = (mod == null ? void 0 : mod.transform) || ((_a = mod == null ? void 0 : mod.default) == null ? void 0 : _a.transform);
+    if (typeof transform !== "function") return code;
+    const res = transform(code, {
+      transforms: ["jsx"],
+      jsxPragma: "ctx.React.createElement",
+      jsxFragmentPragma: "ctx.React.Fragment",
+      // Keep ES syntax as-is; JSRunner runs in modern engines
+      disableESTransforms: true,
+      production: true
+    });
+    return (res && (res.code || (res == null ? void 0 : res.output))) ?? code;
+  } catch (_e) {
+    return code;
+  }
+}
+__name(compileRunJs, "compileRunJs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileRunJs
+});

package/lib/utils/params-resolvers.js

@@ -44,8 +44,8 @@ __export(params_resolvers_exports, {
   resolveExpressions: () => resolveExpressions
 });
 module.exports = __toCommonJS(params_resolvers_exports);
+var import_shared = require("@nocobase/shared");
 var import_lodash = __toESM(require("lodash"));
-var import_client = require("@nocobase/utils/client");
 async function resolveDefaultParams(defaultParams, ctx) {
   if (!defaultParams) {
     return {};
@@ -266,8 +266,9 @@ async function preprocessExpression(expression, ctx) {
 __name(preprocessExpression, "preprocessExpression");
 async function compileExpression(expression, ctx) {
   const matchDotOnly = /* @__PURE__ */ __name((expr) => {
-    const m = expr.trim().match(/^ctx\.([a-zA-Z_$][a-zA-Z0-9_$]*(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*)*)$/);
-    return m ? m[1] : null;
+    const m = expr.trim().match(/^ctx\.([a-zA-Z_$][a-zA-Z0-9_$]*)(?:\.([a-zA-Z_$][a-zA-Z0-9_$-]*(?:\.[a-zA-Z_$][a-zA-Z0-9_$-]*)*))?$/);
+    if (!m) return null;
+    return m[2] ? `${m[1]}.${m[2]}` : m[1];
   }, "matchDotOnly");
   const resolveDotOnlyPath = /* @__PURE__ */ __name(async (dotPath) => {
     const segs = dotPath.split(".");
@@ -275,22 +276,28 @@ async function compileExpression(expression, ctx) {
     if (!first) return void 0;
     const base = await ctx[first];
     if (segs.length === 0) return base;
-    return (0, import_client.getValuesByPath)(base, segs.join("."));
+    return (0, import_shared.getValuesByPath)(base, segs.join("."));
   }, "resolveDotOnlyPath");
-  const singleMatch = expression.match(/^\{\{\s*(.+)\s*\}\}$/);
-  if (singleMatch) {
-    const inner = singleMatch[1];
-    const dotPath = matchDotOnly(inner);
+  const resolveInnerExpression = /* @__PURE__ */ __name(async (innerExpr) => {
+    const dotPath = matchDotOnly(innerExpr);
     if (dotPath) {
-      return await resolveDotOnlyPath(dotPath);
+      const resolved = await resolveDotOnlyPath(dotPath);
+      if (resolved === void 0 && dotPath.includes("-")) {
+        return await processExpression(innerExpr, ctx);
+      }
+      return resolved;
     }
-    return await processExpression(inner, ctx);
+    return await processExpression(innerExpr, ctx);
+  }, "resolveInnerExpression");
+  const singleMatch = expression.match(/^\s*\{\{\s*([^{}]+?)\s*\}\}\s*$/);
+  if (singleMatch) {
+    const inner = singleMatch[1];
+    return await resolveInnerExpression(inner);
   }
   const matches = [...expression.matchAll(/\{\{\s*(.+?)\s*\}\}/g)];
   let result = expression;
   for (const [fullMatch, innerExpr] of matches) {
-    const dotPath = matchDotOnly(innerExpr);
-    const value = dotPath ? await resolveDotOnlyPath(dotPath) : await processExpression(innerExpr, ctx);
+    const value = await resolveInnerExpression(innerExpr);
     if (value !== void 0) {
       const replacement = typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
       result = result.replace(fullMatch, replacement);

package/lib/utils/parsePathnameToViewParams.d.ts

@@ -12,7 +12,7 @@ export interface ViewParam {
     /** 标签页唯一标识符 */
     tabUid?: string;
     /** 弹窗记录的 id */
-    filterByTk?: string;
+    filterByTk?: string | Record<string, string | number>;
     /** source Id */
     sourceId?: string;
 }

package/lib/utils/parsePathnameToViewParams.js

@@ -54,16 +54,52 @@ const parsePathnameToViewParams = /* @__PURE__ */ __name((pathname) => {
         break;
       }
     } else if (currentView && i + 1 < segments.length) {
-      const value = segments[i + 1];
+      const rawValue = segments[i + 1];
+      let decoded = rawValue;
+      try {
+        decoded = decodeURIComponent(rawValue);
+      } catch (_) {
+      }
       switch (segment) {
         case "tab":
-          currentView.tabUid = value;
+          currentView.tabUid = decoded;
           break;
-        case "filterbytk":
-          currentView.filterByTk = value;
+        case "filterbytk": {
+          const parseKeyValuePairs = /* @__PURE__ */ __name((s) => {
+            const obj = {};
+            s.split("&").forEach((pair) => {
+              const [k, v = ""] = pair.split("=");
+              if (!k) return;
+              try {
+                const key = decodeURIComponent(k);
+                const val = decodeURIComponent(v);
+                obj[key] = val;
+              } catch (_) {
+                obj[k] = v;
+              }
+            });
+            return obj;
+          }, "parseKeyValuePairs");
+          let parsed = decoded;
+          if (decoded && (decoded.startsWith("{") || decoded.startsWith("["))) {
+            try {
+              const maybe = JSON.parse(decoded);
+              if (maybe && typeof maybe === "object" && !Array.isArray(maybe)) {
+                parsed = maybe;
+              } else {
+                parsed = decoded;
+              }
+            } catch (_) {
+              parsed = decoded;
+            }
+          } else if (decoded && decoded.includes("=") && decoded.includes("&")) {
+            parsed = parseKeyValuePairs(decoded);
+          }
+          currentView.filterByTk = parsed;
           break;
+        }
         case "sourceid":
-          currentView.sourceId = value;
+          currentView.sourceId = decoded;
           break;
         default:
           break;

package/lib/utils/pruneFilter.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ */
+/**
+ * 递归清理筛选对象中的“空值”。
+ *
+ * 规则：
+ * - 移除：`null`、`undefined`、空字符串 `''`、空数组 `[]`、空对象 `{}`；
+ * - 保留：`false`、`0` 等有意义的“假值”。
+ *
+ * 注意：当清理后整体变为空结构时，返回 `undefined`，用于表示无需下发该条件。
+ *
+ * @param input 任意筛选对象/数组/原始值
+ * @returns 清理后的对象；若为空则返回 `undefined`
+ */
+export declare function pruneFilter<T = any>(input: T): T | undefined;