@nocobase/flow-engine 2.0.0-alpha.4 → 2.0.0-alpha.41

package/src/utils/__tests__/variablesParams.test.ts

@@ -11,6 +11,7 @@ import { describe, expect, it } from 'vitest';
 import {
   collectContextParamsForTemplate,
   createRecordMetaFactory,
+  createRecordResolveOnServerWithLocal,
   inferParentRecordRef,
   inferRecordRef,
 } from '../variablesParams';
@@ -49,4 +50,66 @@ describe('variablesParams helpers', () => {
     expect(res).toHaveProperty('record');
     expect(res).not.toHaveProperty('user');
   });
+
+  it('createRecordResolveOnServerWithLocal: no local record => always use server', () => {
+    const resolver = createRecordResolveOnServerWithLocal(
+      () => ({ name: 'posts', dataSourceKey: 'main' }) as any,
+      () => undefined,
+    );
+    expect(resolver('')).toBe(true);
+    expect(resolver('title')).toBe(true);
+    expect(resolver('author.name')).toBe(true);
+  });
+
+  it('createRecordResolveOnServerWithLocal: local record + non-association subpaths => use local', () => {
+    const collection: any = {
+      getField: (name: string) => {
+        if (name === 'id') return { name: 'id', isAssociationField: () => false };
+        if (name === 'title') return { name: 'title', isAssociationField: () => false };
+        return undefined;
+      },
+    };
+    const record = { id: 1, title: 'Hello' };
+    const resolver = createRecordResolveOnServerWithLocal(
+      () => collection,
+      () => record,
+    );
+    expect(resolver('')).toBe(false);
+    expect(resolver('id')).toBe(false);
+    expect(resolver('title')).toBe(false);
+  });
+
+  it('createRecordResolveOnServerWithLocal: association with local value => still use local', () => {
+    const collection: any = {
+      getField: (name: string) => {
+        if (name === 'author') return { name: 'author', isAssociationField: () => true };
+        if (name === 'title') return { name: 'title', isAssociationField: () => false };
+        return undefined;
+      },
+    };
+    const record = { title: 'Hello', author: { id: 1, name: 'Alice' } };
+    const resolver = createRecordResolveOnServerWithLocal(
+      () => collection,
+      () => record,
+    );
+    expect(resolver('author')).toBe(false);
+    expect(resolver('author.name')).toBe(false);
+  });
+
+  it('createRecordResolveOnServerWithLocal: association without local value => use server', () => {
+    const collection: any = {
+      getField: (name: string) => {
+        if (name === 'author') return { name: 'author', isAssociationField: () => true };
+        if (name === 'title') return { name: 'title', isAssociationField: () => false };
+        return undefined;
+      },
+    };
+    const record = { title: 'Hello', author: null };
+    const resolver = createRecordResolveOnServerWithLocal(
+      () => collection,
+      () => record,
+    );
+    expect(resolver('author')).toBe(true);
+    expect(resolver('author.name')).toBe(true);
+  });
 });

package/src/utils/associationObjectVariable.ts

@@ -0,0 +1,180 @@
+/**
+ * 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 { Collection, CollectionField } from '../data-source';
+import _ from 'lodash';
+import type { FlowContext, PropertyMeta, PropertyMetaFactory } from '../flowContext';
+import { createCollectionContextMeta } from './createCollectionContextMeta';
+
+/**
+ * 提取变量子路径的顶层字段名。
+ * 例如：
+ * - 'author.name'  => 'author'
+ * - 'tags[0].name' => 'tags'
+ *
+ * @param subPath 变量在对象中的子路径字符串
+ * @returns 顶层字段名，找不到时返回 undefined
+ */
+function baseFieldNameOf(subPath: string): string | undefined {
+  if (!subPath) return undefined;
+  const m = subPath.match(/^([^.[]+)/);
+  return m?.[1];
+}
+
+/**
+ * 在集合中根据字段名查找字段定义，兼容 getField/getFields 两种方式。
+ *
+ * @param collection 集合对象
+ * @param name 字段名
+ * @returns 匹配的字段定义，找不到时返回 undefined
+ */
+function findFieldByName(collection: Collection | null | undefined, name?: string): CollectionField | undefined {
+  if (!collection || !name) return undefined;
+  const direct = collection.getField(name);
+  if (direct) return direct;
+  const fields = collection.getFields?.() || [];
+  return fields.find((f) => f.name === name);
+}
+
+/**
+ * 从值中提取主键：
+ * - 支持主键原始值（string/number）
+ * - 支持对象（按主键名取值）
+ *
+ * @param value 字段当前值
+ * @param primaryKey 主键字段名
+ * @returns 解析出的主键值，无法解析时返回 undefined
+ */
+function toFilterByTk(value: unknown, primaryKey: string | string[]) {
+  if (value == null) return undefined;
+  if (Array.isArray(primaryKey)) {
+    if (typeof value !== 'object' || !value) return undefined;
+    const out: Record<string, any> = {};
+    for (const k of primaryKey) {
+      const v = (value as any)[k];
+      if (typeof v === 'undefined' || v === null) return undefined;
+      out[k] = v;
+    }
+    return out;
+  }
+  if (typeof value === 'string' || typeof value === 'number') return value;
+  if (typeof value === 'object') {
+    return (value as any)[primaryKey];
+  }
+  return undefined;
+}
+
+/**
+ * 创建一个用于“对象类变量”（如 formValues / currentObject）的 `resolveOnServer` 判定函数。
+ * 仅当访问路径以“关联字段名”开头（且继续访问其子属性）时，返回 true 交由服务端解析；
+ * 否则在前端解析即可。
+ *
+ * @param collectionAccessor 返回当前对象所在 collection
+ * @param valueAccessor 可选，本地值访问器。若本地已存在目标子路径的值，则认为无需走后端，优先使用本地值。
+ * @returns `(subPath) => boolean` 判断是否需要服务端解析
+ */
+export function createAssociationSubpathResolver(
+  collectionAccessor: () => Collection | null,
+  valueAccessor?: () => unknown,
+): (subPath: string) => boolean {
+  return (p: string) => {
+    // 仅在访问子属性时才考虑后端
+    if (!p || !p.includes('.')) return false;
+    const base = baseFieldNameOf(p);
+    if (!base) return false;
+    const collection = collectionAccessor();
+    const field = findFieldByName(collection, base);
+    const isAssoc = !!field?.isAssociationField();
+    if (!isAssoc) return false;
+
+    // 可选：本地优先。当提供 valueAccessor 时，若本地已有该子路径值，则不走后端
+    if (typeof valueAccessor === 'function') {
+      const local = valueAccessor();
+      if (local && typeof local === 'object') {
+        const v = _.get(local as Record<string, unknown>, p);
+        if (typeof v !== 'undefined') return false;
+      }
+    }
+
+    return true;
+  };
+}
+
+/**
+ * 构建“对象类变量”的 PropertyMetaFactory：
+ * - 暴露集合字段结构（通过 createCollectionContextMeta）用于变量选择器；
+ * - 提供 buildVariablesParams：基于对象当前值，收集所有“已选择的关联字段”
+ *   以便服务端在 variables:resolve 时按需补全关联数据。
+ *
+ * @param collectionAccessor 获取集合对象，用于字段/元信息来源
+ * @param title 变量组标题（用于 UI 展示）
+ * @param valueAccessor 获取当前对象值（如 ctx.form.getFieldsValue() / ctx.currentObject）
+ * @returns PropertyMetaFactory
+ */
+export function createAssociationAwareObjectMetaFactory(
+  collectionAccessor: () => Collection | null,
+  title: string,
+  valueAccessor: (ctx: FlowContext) => any,
+): PropertyMetaFactory {
+  const baseFactory = createCollectionContextMeta(collectionAccessor, title);
+  const factory: PropertyMetaFactory = async () => {
+    const base = (await baseFactory()) as PropertyMeta | null;
+    if (!base) return null;
+
+    const meta: PropertyMeta = {
+      ...base,
+      buildVariablesParams: (ctx: FlowContext) => {
+        const collection = collectionAccessor();
+        const obj = valueAccessor(ctx);
+        if (!collection || !obj || typeof obj !== 'object') return {};
+        const params: Record<string, any> = {};
+
+        const fields: CollectionField[] = collection.getFields?.() || [];
+        for (const field of fields) {
+          const name = field.name as string | undefined;
+          if (!name) continue;
+          if (!field.isAssociationField()) continue;
+          const target = field.target as string | undefined;
+          const targetCollection = field.targetCollection;
+          if (!target || !targetCollection) continue;
+          const primaryKey = targetCollection.filterTargetKey as string | string[];
+
+          const associationValue = (obj as any)[name];
+          if (associationValue == null) continue;
+
+          if (Array.isArray(associationValue)) {
+            const ids = associationValue.map((item) => toFilterByTk(item, primaryKey)).filter((v) => v != null);
+            if (ids.length) {
+              params[name] = {
+                collection: target,
+                dataSourceKey: targetCollection.dataSourceKey,
+                filterByTk: ids,
+              };
+            }
+          } else {
+            const id = toFilterByTk(associationValue, primaryKey);
+            if (id != null) {
+              params[name] = {
+                collection: target,
+                dataSourceKey: targetCollection.dataSourceKey,
+                filterByTk: id,
+              };
+            }
+          }
+        }
+
+        return params;
+      },
+    };
+
+    return meta;
+  };
+  factory.title = title;
+  return factory;
+}

package/src/utils/buildSettingsViewInputArgs.ts

@@ -0,0 +1,72 @@
+/**
+ * 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 { FlowModel } from '../models';
+import { inferRecordRef } from './variablesParams';
+
+/**
+ * 统一构造设置弹窗 openView 的 inputArgs：
+ * - collectionName/dataSourceKey/filterByTk：优先从 model.context 推断；否则回退父视图 inputArgs
+ * - sourceId：优先从 resource.getSourceId()；否则回退父视图 inputArgs
+ * - associationName：来自 association.resourceName 或 resource.getResourceName()
+ * - navigation：父视图 navigation 或传入的 navigationOverride
+ */
+export function buildSettingsViewInputArgs(
+  model: FlowModel,
+  extra?: Record<string, any>,
+  options?: { navigationOverride?: any },
+): Record<string, any> {
+  const defaults: Record<string, any> = {};
+
+  try {
+    // 1) 当前记录/集合
+    const ref = inferRecordRef((model as any).context);
+    if (ref?.collection) {
+      defaults.collectionName = ref.collection;
+      defaults.dataSourceKey = ref.dataSourceKey || 'main';
+      defaults.filterByTk = ref.filterByTk;
+    }
+
+    // 2) 回退父视图 inputArgs（如在抽屉/页面中）
+    const parentArgs = (model as any)?.context?.view?.inputArgs || {};
+    if (!defaults.collectionName && parentArgs?.collectionName) {
+      defaults.collectionName = parentArgs.collectionName;
+      defaults.dataSourceKey = parentArgs.dataSourceKey || defaults.dataSourceKey || 'main';
+    }
+    if (defaults.filterByTk == null && parentArgs?.filterByTk != null) {
+      defaults.filterByTk = parentArgs.filterByTk;
+    }
+    if (defaults.sourceId == null && parentArgs?.sourceId != null) {
+      defaults.sourceId = parentArgs.sourceId;
+    }
+
+    // 3) 导航（用于推断“上级弹窗”）
+    const nav = options?.navigationOverride ?? (model as any)?.context?.view?.navigation;
+    if (nav) {
+      defaults.navigation = nav;
+    }
+
+    // 4) 直接从资源读取 sourceId（优先级高于父视图）
+    const sid = (model as any)?.context?.resource?.getSourceId?.();
+    if (sid !== undefined && sid !== null && String(sid) !== '') {
+      defaults.sourceId = sid;
+    }
+
+    // 5) 关联名（用于“上级记录”）
+    const assocName =
+      (model as any)?.context?.association?.resourceName || (model as any)?.context?.resource?.getResourceName?.();
+    if (typeof assocName === 'string' && assocName) {
+      defaults.associationName = assocName;
+    }
+  } catch (_) {
+    // 忽略推断异常
+  }
+
+  return { ...defaults, ...(extra || {}) };
+}

package/src/utils/createEphemeralContext.ts

@@ -0,0 +1,142 @@
+/**
+ * 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';
+import type { PropertyOptions } from '../flowContext';
+
+// 临时上下文：
+// - 读：优先从 scoped（临时定义）读取，兜底 parent；
+// - 写：统一写入 parent（不污染 scoped）；
+// - 注入：create 阶段 define* 写入 scoped；运行阶段 define* 写入 parent。
+type ContextDefsLike<TCtx extends FlowContext> =
+  | Partial<Pick<ActionDefinition<any, TCtx>, 'defineProperties' | 'defineMethods'>>
+  | null
+  | undefined;
+
+export async function createEphemeralContext<TCtx extends FlowContext>(
+  parent: TCtx,
+  contextDefs?: ContextDefsLike<TCtx>,
+): Promise<TCtx> {
+  // 若未提供任何上下文定义，直接复用父级上下文，避免不必要的代理包装
+  if (contextDefs == null || (!contextDefs.defineProperties && !contextDefs.defineMethods)) {
+    return parent;
+  }
+  // 1) 创建一个新的 FlowContext，专门承载“临时定义”（defineProperty/defineMethod）
+  const scoped = new FlowContext();
+  // 2) 读取优先：先从 scoped 自身取（_props/_methods），否则委托到 parent（仅 _props/_methods）
+  scoped.addDelegate(parent);
+
+  // 3) 先创建 scoped 的代理，用于注入阶段（define* 直达 scoped；读写行为与最终代理一致）
+  const scopedProxy = scoped.createProxy();
+  const scopedObj = scopedProxy as unknown as object;
+  const parentObj = parent as unknown as object;
+  const getFromParent = (key: PropertyKey) => {
+    const val = Reflect.get(parentObj, key, parentObj);
+    return typeof val === 'function' ? (val as Function).bind(parent) : val;
+  };
+  const hasInScopedOrParent = (key: PropertyKey) =>
+    key === 'defineProperty' || key === 'defineMethod' || Reflect.has(scopedObj, key) || Reflect.has(parentObj, key);
+  const injectionProxy = new Proxy(scopedProxy as TCtx, {
+    get(_t, key: PropertyKey, receiver) {
+      if (typeof key === 'string') {
+        // 注入阶段：允许在 defLike 的函数体中调用 ctx.defineProperty/defineMethod 写入 scoped
+        if (key === 'defineProperty') {
+          return (propKey: string, options: any) => (scoped as FlowContext).defineProperty(propKey, options);
+        }
+        if (key === 'defineMethod') {
+          return (name: string, fn: any, des?: string) => (scoped as FlowContext).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: PropertyKey, value: unknown) {
+      return Reflect.set(parentObj, key, value);
+    },
+    has(_t, key: PropertyKey) {
+      return hasInScopedOrParent(key);
+    },
+    getOwnPropertyDescriptor(_t, key: PropertyKey) {
+      return Object.getOwnPropertyDescriptor(scopedObj, key) || Object.getOwnPropertyDescriptor(parentObj, key);
+    },
+  });
+
+  // 如果提供了 contextDefs，则在创建时即注入定义，便于外部更简洁地使用
+  if (contextDefs) {
+    const defs = Array.isArray(contextDefs) ? contextDefs : [contextDefs];
+    for (const defLike of defs) {
+      if (!defLike) continue;
+      // 1) defineProperties -> 写入到 scoped（避免污染父级）
+      const dp = (defLike as any).defineProperties;
+      if (dp) {
+        const raw = typeof dp === 'function' ? await dp(injectionProxy as TCtx) : dp;
+        if (!raw || typeof raw !== 'object') {
+          throw new TypeError('defineProperties must return an object of PropertyOptions');
+        }
+        const propsDef = raw as Record<string, PropertyOptions>;
+        for (const [key, options] of Object.entries(propsDef)) {
+          if (!options || typeof options !== 'object') {
+            throw new TypeError(`defineProperties['${key}'] must be a PropertyOptions object`);
+          }
+          // 直接在 scoped 上定义，确保仅限本次临时作用域
+          (scoped as FlowContext).defineProperty(key, options);
+        }
+      }
+      // 2) defineMethods -> 写入到 scoped（避免污染父级）
+      const dm = (defLike as any).defineMethods;
+      if (dm) {
+        const raw = typeof dm === 'function' ? await dm(injectionProxy as TCtx) : dm;
+        if (!raw || typeof raw !== 'object') {
+          throw new TypeError('defineMethods must return an object of functions');
+        }
+        const methodsDef = raw as Record<string, (this: TCtx, ...args: any[]) => any>;
+        for (const [key, fn] of Object.entries(methodsDef)) {
+          if (typeof fn !== 'function') {
+            throw new TypeError(`defineMethods['${key}'] must be a function`);
+          }
+          (scoped as FlowContext).defineMethod(key, fn as any);
+        }
+      }
+    }
+  }
+
+  // 4) 创建最终对外代理：读取优先 scoped，兜底父级，且后续 define* 写入父级
+  const outerProxy = new Proxy(scopedProxy as TCtx, {
+    get(_t, key: PropertyKey, receiver) {
+      if (typeof key === 'string') {
+        if (key === 'defineProperty') {
+          return (propKey: string, options: any) => (parent as FlowContext).defineProperty(propKey, options);
+        }
+        if (key === 'defineMethod') {
+          return (name: string, fn: any, des?: string) => (parent as FlowContext).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: PropertyKey, value: unknown) {
+      return Reflect.set(parentObj, key, value);
+    },
+    has(_t, key: PropertyKey) {
+      return hasInScopedOrParent(key);
+    },
+    getOwnPropertyDescriptor(_t, key: PropertyKey) {
+      return Object.getOwnPropertyDescriptor(scopedObj, key) || Object.getOwnPropertyDescriptor(parentObj, key);
+    },
+  });
+
+  return outerProxy as TCtx;
+}

package/src/utils/flows.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 const isBeforeRenderFlow = (flow: FlowDefinition): boolean => {
+  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;
+};

package/src/utils/index.ts

@@ -41,14 +41,15 @@ export { setupRuntimeContextSteps } from './setupRuntimeContextSteps';
 
 // Record Proxy 工具
 export { createCollectionContextMeta } from './createCollectionContextMeta';
+export { createAssociationAwareObjectMetaFactory, createAssociationSubpathResolver } from './associationObjectVariable';
 export {
   buildRecordMeta,
   collectContextParamsForTemplate,
   createCurrentRecordMetaFactory,
+  createRecordResolveOnServerWithLocal,
   createRecordMetaFactory,
   extractUsedVariableNames,
   extractUsedVariablePaths,
-  inferParentRecordRef,
   inferRecordRef,
   type RecordParamsBuilder,
 } from './variablesParams';
@@ -58,6 +59,14 @@ export { extractPropertyPath, formatPathToVariable, isVariableExpression } from
 
 export { clearAutoFlowError, getAutoFlowError, setAutoFlowError, type AutoFlowError } from './autoFlowError';
 export { parsePathnameToViewParams, type ViewParam } from './parsePathnameToViewParams';
+export { buildSettingsViewInputArgs } from './buildSettingsViewInputArgs';
 
 // 安全全局对象（window/document）
-export { createSafeDocument, createSafeWindow } from './safeGlobals';
+export { createSafeDocument, createSafeWindow, createSafeNavigator } from './safeGlobals';
+
+// Ephemeral context helper（用于临时注入属性/方法，避免污染父级 ctx）
+export { createEphemeralContext } from './createEphemeralContext';
+
+// Filter helpers
+export { pruneFilter } from './pruneFilter';
+export { isBeforeRenderFlow } from './flows';

package/src/utils/jsxTransform.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 async function compileRunJs(code: string): Promise<string> {
+  // Fast path: cheap heuristic to skip import if no JSX likely present
+  // (not strict; still safe because we fall back to transform if dynamic import is cheap)
+  const maybeJSX = /<[A-Za-z]|<\//.test(code);
+  if (!maybeJSX) return code;
+
+  try {
+    const mod: any = await import('sucrase');
+    const transform = mod?.transform || mod?.default?.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?.output)) ?? code;
+  } catch (_e) {
+    // Fallback: return original code if transform fails
+    return code;
+  }
+}

package/src/utils/params-resolvers.ts

@@ -7,9 +7,9 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
+import { getValuesByPath } from '@nocobase/shared';
 import _ from 'lodash';
 import { FlowContext, FlowModelContext, FlowRuntimeContext } from '../flowContext';
-import { getValuesByPath } from '@nocobase/utils/client';
 import type { FlowModel } from '../models';
 import type { ServerContextParams } from './serverContextParams';
 
@@ -440,7 +440,7 @@ async function compileExpression<TModel extends FlowModel = FlowModel>(expressio
    * ✅ "{{ctx.user}}"            -> 捕获: "ctx.user"
    * ❌ "Hello {{ ctx.user }}"    -> 不匹配（不是纯表达式）
    */
-  const singleMatch = expression.match(/^\{\{\s*(.+)\s*\}\}$/);
+  const singleMatch = expression.match(/^\s*\{\{\s*([^{}]+?)\s*\}\}\s*$/);
   if (singleMatch) {
     const inner = singleMatch[1];
     const dotPath = matchDotOnly(inner);

package/src/utils/parsePathnameToViewParams.ts

@@ -13,7 +13,7 @@ export interface ViewParam {
   /** 标签页唯一标识符 */
   tabUid?: string;
   /** 弹窗记录的 id */
-  filterByTk?: string;
+  filterByTk?: string | Record<string, string | number>;
   /** source Id */
   sourceId?: string;
 }
@@ -70,17 +70,61 @@ export const parsePathnameToViewParams = (pathname: string): ViewParam[] => {
     }
     // 处理参数
     else if (currentView && i + 1 < segments.length) {
-      const value = segments[i + 1];
+      const rawValue = segments[i + 1];
+      // 尝试对路径段进行解码
+      let decoded: string = rawValue;
+      try {
+        decoded = decodeURIComponent(rawValue);
+      } catch (_) {
+        // ignore
+      }
 
       switch (segment) {
         case 'tab':
-          currentView.tabUid = value;
+          // tab/sourceId 仅作为字符串处理
+          currentView.tabUid = decoded;
           break;
-        case 'filterbytk':
-          currentView.filterByTk = value;
+        case 'filterbytk': {
+          // 仅在 filterByTk 分支支持对象/JSON/键值对解析
+          const parseKeyValuePairs = (s: string): Record<string, string | number> => {
+            const obj: Record<string, string | number> = {};
+            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;
+          };
+
+          let parsed: string | Record<string, string | number> = decoded;
+          if (decoded && (decoded.startsWith('{') || decoded.startsWith('['))) {
+            try {
+              const maybe = JSON.parse(decoded);
+              if (maybe && typeof maybe === 'object' && !Array.isArray(maybe)) {
+                parsed = maybe as Record<string, string | number>;
+              } else {
+                // 非对象 JSON（如数组/数字）按字符串保留
+                parsed = decoded;
+              }
+            } catch (_) {
+              // 解析失败，按字符串保留
+              parsed = decoded;
+            }
+          } else if (decoded && decoded.includes('=') && decoded.includes('&')) {
+            // 形如 a=b&c=d 的整体段
+            parsed = parseKeyValuePairs(decoded);
+          }
+          currentView.filterByTk = parsed;
           break;
+        }
         case 'sourceid':
-          currentView.sourceId = value;
+          currentView.sourceId = decoded;
           break;
         default:
           // 未知参数，跳过