@nocobase/flow-engine 2.1.11 → 2.2.0-alpha.2

package/src/resources/baseRecordResource.ts

@@ -12,7 +12,7 @@ import _ from 'lodash';
 import { APIResource } from './apiResource';
 import { FilterItem } from './filterItem';
 import { ResourceError } from './flowResource';
-import { DATA_SOURCE_DIRTY_EVENT } from '../views/viewEvents';
+import { markDataSourceDirty } from '../utils/dataSourceDirty';
 
 export abstract class BaseRecordResource<TData = any> extends APIResource<TData> {
   protected resourceName: string;
@@ -142,28 +142,11 @@ export abstract class BaseRecordResource<TData = any> extends APIResource<TData>
    * Used to coordinate "refresh on active" across view stacks.
    */
   protected markDataSourceDirty(resourceName?: string) {
-    const engine = this.context.engine;
-    if (!engine) return;
-
-    const dataSourceKey = this.getDataSourceKey() || 'main';
-    const resName = resourceName || this.getResourceName();
-    if (!resName) return;
-
-    const affectedResourceNames = new Set<string>([String(resName)]);
-    // Optional safety: association resources like "users.profile" may impact parent collection views.
-    if (typeof resName === 'string' && resName.includes('.')) {
-      affectedResourceNames.add(resName.split('.')[0]);
-    }
-
-    for (const name of affectedResourceNames) {
-      engine.markDataSourceDirty(dataSourceKey, name);
-    }
-
-    // Signal current view to re-evaluate dirty blocks (e.g., same-view sibling refresh).
-    // This is emitted on the *current* engine emitter (view-scoped) so it won't affect other views.
-    engine.emitter?.emit?.(DATA_SOURCE_DIRTY_EVENT, {
-      dataSourceKey,
-      resourceNames: Array.from(affectedResourceNames),
+    markDataSourceDirty({
+      engine: this.context.engine,
+      dataSourceKey: this.getDataSourceKey(),
+      resourceName: resourceName || this.getResourceName(),
+      includePreviousEngines: true,
     });
   }
 

package/src/resources/multiRecordResource.ts

@@ -10,6 +10,7 @@
 import { observable } from '@formily/reactive';
 import { AxiosRequestConfig } from 'axios';
 import _ from 'lodash';
+import { SKIP_DATA_SOURCE_DIRTY } from '../utils/dirtyAwareApiClient';
 import { BaseRecordResource } from './baseRecordResource';
 
 export class MultiRecordResource<TDataItem = any> extends BaseRecordResource<TDataItem[]> {
@@ -113,7 +114,10 @@ export class MultiRecordResource<TDataItem = any> extends BaseRecordResource<TDa
 
   async create(data: TDataItem, options?: AxiosRequestConfig & { refresh?: boolean }): Promise<void> {
     const config = this.mergeRequestConfig({ data }, this.createActionOptions, options);
-    const res = await this.runAction('create', config);
+    const res = await this.runAction('create', {
+      ...config,
+      [SKIP_DATA_SOURCE_DIRTY]: true,
+    });
     this.markDataSourceDirty();
     this.emit('saved', data);
     if (options?.refresh !== false) {
@@ -146,7 +150,10 @@ export class MultiRecordResource<TDataItem = any> extends BaseRecordResource<TDa
       this.updateActionOptions,
       options,
     );
-    await this.runAction('update', config);
+    await this.runAction('update', {
+      ...config,
+      [SKIP_DATA_SOURCE_DIRTY]: true,
+    });
     this.markDataSourceDirty();
     this.emit('saved', data);
     await this.refresh();
@@ -172,7 +179,10 @@ export class MultiRecordResource<TDataItem = any> extends BaseRecordResource<TDa
       },
       options,
     );
-    await this.runAction('destroy', config);
+    await this.runAction('destroy', {
+      ...config,
+      [SKIP_DATA_SOURCE_DIRTY]: true,
+    });
     this.markDataSourceDirty();
     const currentPage = this.getPage();
     const lastPage = Math.ceil((this.getCount() - _.castArray(filterByTk).length) / this.getPageSize());

package/src/resources/singleRecordResource.ts

@@ -9,6 +9,7 @@
 
 import { AxiosRequestConfig } from 'axios';
 import _ from 'lodash';
+import { SKIP_DATA_SOURCE_DIRTY } from '../utils/dirtyAwareApiClient';
 import { BaseRecordResource } from './baseRecordResource';
 
 export class SingleRecordResource<TData = any> extends BaseRecordResource<TData> {
@@ -43,6 +44,7 @@ export class SingleRecordResource<TData = any> extends BaseRecordResource<TData>
     const res = await this.runAction(actionName, {
       ...config,
       data: result,
+      [SKIP_DATA_SOURCE_DIRTY]: true,
     });
     // Mark as dirty before emitting/refreshing so other views can refresh when activated.
     this.markDataSourceDirty();
@@ -62,7 +64,10 @@ export class SingleRecordResource<TData = any> extends BaseRecordResource<TData>
       },
       options,
     );
-    await this.runAction('destroy', config);
+    await this.runAction('destroy', {
+      ...config,
+      [SKIP_DATA_SOURCE_DIRTY]: true,
+    });
     this.markDataSourceDirty();
     this.setData(null);
   }

package/src/runjs-context/helpers.ts

@@ -46,12 +46,17 @@ export function createJSRunnerWithVersion(this: FlowContext, options?: JSRunnerO
     doc = {};
   }
   const deprecatedCtx = createRunJSDeprecationProxy(runCtx, { doc });
-  const globals: Record<string, any> = { ctx: deprecatedCtx, ...(options?.globals || {}) };
-  // 对字段/区块类上下文，默认注入 window/document 以支持在沙箱中访问 DOM API
-  if (modelClass === 'JSFieldModel' || modelClass === 'JSBlockModel') {
-    if (typeof window !== 'undefined') globals.window = window as any;
-    if (typeof document !== 'undefined') globals.document = document as any;
+  const browserGlobals: Record<string, any> = {};
+  if (typeof window !== 'undefined') {
+    browserGlobals.window = window;
+    if (typeof navigator !== 'undefined') {
+      browserGlobals.navigator = navigator;
+    }
   }
+  if (typeof document !== 'undefined') {
+    browserGlobals.document = document;
+  }
+  const globals: Record<string, any> = { ctx: deprecatedCtx, ...browserGlobals, ...(options?.globals || {}) };
   // 透传 JSRunnerOptions 其余配置（如 timeoutMs）
   const { timeoutMs } = options || {};
   return new JSRunner({ globals, timeoutMs });
@@ -59,7 +64,8 @@ export function createJSRunnerWithVersion(this: FlowContext, options?: JSRunnerO
 
 export function getRunJSScenesForModel(modelClass: string, version: RunJSVersion = 'v1'): string[] {
   const meta = RunJSContextRegistry.getMeta(version, modelClass);
-  return Array.isArray(meta?.scenes) ? [...meta!.scenes!] : [];
+  const scenes = meta?.scenes;
+  return Array.isArray(scenes) ? [...scenes] : [];
 }
 
 export function getRunJSScenesForContext(ctx: FlowContext, { version = 'v1' as RunJSVersion } = {}): string[] {

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

@@ -0,0 +1,392 @@
+/**
+ * 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 { describe, expect, it, vi } from 'vitest';
+import { FlowContext } from '../../flowContext';
+import { FlowEngine } from '../../flowEngine';
+import { createViewScopedEngine } from '../../ViewScopedFlowEngine';
+import { DATA_SOURCE_DIRTY_EVENT } from '../../views/viewEvents';
+import { getDirtyAwareApiClient, SKIP_DATA_SOURCE_DIRTY } from '../dirtyAwareApiClient';
+
+type TestRequestOptions = {
+  url?: string;
+  resource?: string;
+  action?: string;
+  headers?: Record<string, string>;
+  params?: unknown;
+};
+
+type TestResource = Record<string, (...args: unknown[]) => Promise<unknown>>;
+
+type TestApi = {
+  auth: { locale: string };
+  request: (config: TestRequestOptions) => Promise<unknown>;
+  resource: (name: string, of?: unknown, headers?: Record<string, string>, cancel?: boolean) => TestResource;
+};
+
+function getWrappedApi(engine: FlowEngine, api: TestApi): TestApi {
+  return getDirtyAwareApiClient(api, engine.context) as TestApi;
+}
+
+describe('dirtyAwareApiClient', () => {
+  it('should return non-api values as-is', () => {
+    const context = new FlowContext();
+    const value = { request: vi.fn() };
+
+    expect(getDirtyAwareApiClient(value, context)).toBe(value);
+  });
+
+  it('should mark the resource dirty after mutating resource actions succeed', async () => {
+    const engine = new FlowEngine();
+    const list = vi.fn(async () => ({ data: { data: [] } }));
+    const update = vi.fn(async () => ({ data: { data: { id: 1 } } }));
+    const api: TestApi = {
+      auth: { locale: 'zh-CN' },
+      request: vi.fn(async () => ({ data: { ok: true } })),
+      resource: vi.fn(() => ({ list, update })),
+    };
+    const wrappedApi = getWrappedApi(engine, api);
+
+    await wrappedApi.resource('posts').list();
+    expect(engine.getDataSourceDirtyVersion('main', 'posts')).toBe(0);
+
+    await wrappedApi.resource('posts').update({ filterByTk: 1, values: { title: 't' } });
+
+    expect(update).toHaveBeenCalledTimes(1);
+    expect(engine.getDataSourceDirtyVersion('main', 'posts')).toBe(1);
+    expect(getDirtyAwareApiClient(api, engine.context)).toBe(wrappedApi);
+  });
+
+  it('should not double-wrap an already dirty-aware api', async () => {
+    const engine = new FlowEngine();
+    const update = vi.fn(async () => ({ data: { data: { id: 1 } } }));
+    const api: TestApi = {
+      auth: { locale: 'zh-CN' },
+      request: vi.fn(async () => ({ data: { ok: true } })),
+      resource: vi.fn(() => ({ update })),
+    };
+
+    const wrappedApi = getWrappedApi(engine, api);
+    const wrappedAgain = getDirtyAwareApiClient(wrappedApi, engine.context) as TestApi;
+    await wrappedAgain.resource('posts').update({ filterByTk: 1 });
+
+    expect(wrappedAgain).toBe(wrappedApi);
+    expect(engine.getDataSourceDirtyVersion('main', 'posts')).toBe(1);
+  });
+
+  it('should not mark dirty for read actions', async () => {
+    const nonMutatingActions = [
+      'get',
+      'getSystemSettings',
+      'list',
+      'listByUser',
+      'query',
+      'count',
+      'check',
+      'preview',
+      'test',
+      'find',
+      'exists',
+      'aggregate',
+      'listMine',
+      'parents',
+      'children',
+      'search',
+      'send',
+      'testConnection',
+      'refresh',
+      'run',
+      'runById',
+      'unknownCustomAction',
+    ];
+
+    for (const actionName of nonMutatingActions) {
+      const engine = new FlowEngine();
+      const api: TestApi = {
+        auth: { locale: 'zh-CN' },
+        request: vi.fn(async () => ({ data: { ok: true } })),
+        resource: vi.fn(() => ({
+          [actionName]: vi.fn(async () => ({ data: { data: [] } })),
+        })),
+      };
+
+      await getWrappedApi(engine, api).resource('posts')[actionName]();
+
+      expect(engine.getDataSourceDirtyVersion('main', 'posts')).toBe(0);
+    }
+  });
+
+  it('should mark dirty for known mutating action variants', async () => {
+    const mutatingActions = [
+      'create',
+      'execute',
+      'updateOrCreate',
+      'firstOrCreate',
+      'setFields',
+      'updateProfile',
+      'saveAsTemplate',
+      'remove/abc',
+    ];
+
+    for (const actionName of mutatingActions) {
+      const engine = new FlowEngine();
+      const api: TestApi = {
+        auth: { locale: 'zh-CN' },
+        request: vi.fn(async () => ({ data: { ok: true } })),
+        resource: vi.fn(() => ({
+          [actionName]: vi.fn(async () => ({ data: { ok: true } })),
+        })),
+      };
+
+      await getWrappedApi(engine, api).resource('posts')[actionName]();
+
+      expect(engine.getDataSourceDirtyVersion('main', 'posts')).toBe(1);
+    }
+  });
+
+  it('should not mark dirty when a mutating action fails', async () => {
+    const engine = new FlowEngine();
+    const update = vi.fn(async () => {
+      throw new Error('update failed');
+    });
+    const api: TestApi = {
+      auth: { locale: 'zh-CN' },
+      request: vi.fn(async () => ({ data: { ok: true } })),
+      resource: vi.fn(() => ({ update })),
+    };
+
+    await expect(getWrappedApi(engine, api).resource('posts').update({ filterByTk: 1 })).rejects.toThrow(
+      'update failed',
+    );
+
+    expect(engine.getDataSourceDirtyVersion('main', 'posts')).toBe(0);
+  });
+
+  it('should mark association resource and parent collection dirty', async () => {
+    const engine = new FlowEngine();
+    const dirtyEvents: Array<{ dataSourceKey: string; resourceNames: string[] }> = [];
+    engine.emitter.on(DATA_SOURCE_DIRTY_EVENT, (event) => dirtyEvents.push(event));
+    const add = vi.fn(async () => ({ data: { data: null } }));
+    const api: TestApi = {
+      auth: { locale: 'zh-CN' },
+      request: vi.fn(async () => ({ data: { ok: true } })),
+      resource: vi.fn(() => ({ add })),
+    };
+
+    await getWrappedApi(engine, api)
+      .resource('users.roles', 1, { 'x-data-source': 'external' })
+      .add({ values: [1, 2] });
+
+    expect(engine.getDataSourceDirtyVersion('external', 'users.roles')).toBe(1);
+    expect(engine.getDataSourceDirtyVersion('external', 'users')).toBe(1);
+    expect(dirtyEvents).toEqual([{ dataSourceKey: 'external', resourceNames: ['users.roles', 'users'] }]);
+  });
+
+  it('should mark resource-action request mutations dirty after success', async () => {
+    const engine = new FlowEngine();
+    const request = vi.fn(async () => ({ data: { ok: true } }));
+    const api: TestApi = {
+      auth: { locale: 'zh-CN' },
+      request,
+      resource: vi.fn(),
+    };
+
+    await getWrappedApi(engine, api).request({
+      resource: 'posts',
+      action: 'update',
+      headers: { 'X-Data-Source': 'analytics' },
+      params: { filterByTk: 1 },
+    });
+
+    expect(request).toHaveBeenCalledTimes(1);
+    expect(engine.getDataSourceDirtyVersion('analytics', 'posts')).toBe(1);
+  });
+
+  it('should mark URL-form resource mutations dirty after success', async () => {
+    const engine = new FlowEngine();
+    const request = vi.fn(async () => ({ data: { ok: true } }));
+    const api: TestApi = {
+      auth: { locale: 'zh-CN' },
+      request,
+      resource: vi.fn(),
+    };
+    const wrappedApi = getWrappedApi(engine, api);
+
+    await wrappedApi.request({ url: 'posts:update' });
+    await wrappedApi.request({
+      url: '/api/posts:update?filterByTk=1',
+      headers: { 'x-data-source': 'external' },
+    });
+    await wrappedApi.request({
+      url: '/api/posts/1/tags:set',
+      headers: { 'X-Data-Source': 'analytics' },
+    });
+
+    expect(request).toHaveBeenCalledTimes(3);
+    expect(engine.getDataSourceDirtyVersion('main', 'posts')).toBe(1);
+    expect(engine.getDataSourceDirtyVersion('external', 'posts')).toBe(1);
+    expect(engine.getDataSourceDirtyVersion('analytics', 'posts.tags')).toBe(1);
+    expect(engine.getDataSourceDirtyVersion('analytics', 'posts')).toBe(1);
+  });
+
+  it('should resolve data source resource URLs to the nested data source target', async () => {
+    const engine = new FlowEngine();
+    const request = vi.fn(async () => ({ data: { ok: true } }));
+    const api: TestApi = {
+      auth: { locale: 'zh-CN' },
+      request,
+      resource: vi.fn(),
+    };
+
+    await getWrappedApi(engine, api).request({
+      url: 'dataSources/external/collections:update',
+    });
+
+    expect(request).toHaveBeenCalledTimes(1);
+    expect(engine.getDataSourceDirtyVersion('external', 'collections')).toBe(1);
+    expect(engine.getDataSourceDirtyVersion('main', 'dataSources.collections')).toBe(0);
+    expect(engine.getDataSourceDirtyVersion('main', 'dataSources')).toBe(0);
+  });
+
+  it('should resolve dataSources resourceOf requests to the nested data source target', async () => {
+    const engine = new FlowEngine();
+    const request = vi.fn(async () => ({ data: { ok: true } }));
+    const update = vi.fn(async () => ({ data: { ok: true } }));
+    const api: TestApi = {
+      auth: { locale: 'zh-CN' },
+      request,
+      resource: vi.fn(() => ({ update })),
+    };
+    const wrappedApi = getWrappedApi(engine, api);
+
+    await wrappedApi.request({
+      resource: 'dataSources.collections',
+      resourceOf: 'external',
+      action: 'update',
+    } as TestRequestOptions & { resourceOf: string });
+    await wrappedApi.resource('dataSources.roles', 'external').update({ values: { allow: true } });
+    await wrappedApi.resource('dataSources/external/roles').update({ values: { allow: false } });
+
+    expect(engine.getDataSourceDirtyVersion('external', 'collections')).toBe(1);
+    expect(engine.getDataSourceDirtyVersion('external', 'roles')).toBe(2);
+    expect(engine.getDataSourceDirtyVersion('main', 'dataSources.collections')).toBe(0);
+    expect(engine.getDataSourceDirtyVersion('main', 'dataSources.roles')).toBe(0);
+  });
+
+  it('should skip dirty marking and strip the internal skip flag from raw requests', async () => {
+    const engine = new FlowEngine();
+    const request = vi.fn(async () => ({ data: { ok: true } }));
+    const api: TestApi = {
+      auth: { locale: 'zh-CN' },
+      request,
+      resource: vi.fn(),
+    };
+
+    await getWrappedApi(engine, api).request({
+      url: 'posts:update',
+      [SKIP_DATA_SOURCE_DIRTY]: true,
+    } as TestRequestOptions & { [SKIP_DATA_SOURCE_DIRTY]: boolean });
+
+    expect(request).toHaveBeenCalledTimes(1);
+    expect(request.mock.calls[0][0]).not.toHaveProperty(SKIP_DATA_SOURCE_DIRTY);
+    expect(engine.getDataSourceDirtyVersion('main', 'posts')).toBe(0);
+  });
+
+  it('should strip configured API base from URL-form mutations', async () => {
+    const engine = new FlowEngine();
+    const request = vi.fn(async () => ({ data: { ok: true } }));
+    const api: TestApi = {
+      auth: { locale: 'zh-CN' },
+      request,
+      resource: vi.fn(),
+    };
+    engine.context.defineProperty('app', {
+      value: {
+        getApiUrl(pathname = '') {
+          return `https://app.example.com/foo/api/${pathname.replace(/^\//, '')}`;
+        },
+      },
+    });
+    const wrappedApi = getWrappedApi(engine, api);
+
+    await wrappedApi.request({ url: '/foo/api/posts:update' });
+    await wrappedApi.request({
+      url: 'https://app.example.com/foo/api/users/1/roles:set',
+      headers: { 'x-data-source': 'external' },
+    });
+
+    expect(request).toHaveBeenCalledTimes(2);
+    expect(engine.getDataSourceDirtyVersion('main', 'posts')).toBe(1);
+    expect(engine.getDataSourceDirtyVersion('main', 'foo.api.posts')).toBe(0);
+    expect(engine.getDataSourceDirtyVersion('external', 'users.roles')).toBe(1);
+    expect(engine.getDataSourceDirtyVersion('external', 'users')).toBe(1);
+  });
+
+  it('should not mark URL-form resource dirty for reads, failed mutations, or external URLs', async () => {
+    const engine = new FlowEngine();
+    const request = vi
+      .fn()
+      .mockResolvedValueOnce({ data: { data: [] } })
+      .mockResolvedValueOnce({ data: { data: [] } })
+      .mockRejectedValueOnce(new Error('request failed'))
+      .mockResolvedValueOnce({ data: { ok: true } })
+      .mockResolvedValueOnce({ data: { ok: true } });
+    const api: TestApi = {
+      auth: { locale: 'zh-CN' },
+      request,
+      resource: vi.fn(),
+    };
+    const wrappedApi = getWrappedApi(engine, api);
+
+    await wrappedApi.request({ url: 'posts:list' });
+    await wrappedApi.request({ url: '/api/posts:parents' });
+    await expect(wrappedApi.request({ url: '/api/posts:update' })).rejects.toThrow('request failed');
+    await wrappedApi.request({ url: 'https://example.com/api/posts:update' });
+    await wrappedApi.request({ url: '//example.com/api/posts:update' });
+
+    expect(request).toHaveBeenCalledTimes(5);
+    expect(engine.getDataSourceDirtyVersion('main', 'posts')).toBe(0);
+  });
+
+  it('should mark opener engine dirty when called from a scoped view context', async () => {
+    const root = new FlowEngine();
+    const scoped = createViewScopedEngine(root);
+    const update = vi.fn(async () => ({ data: { data: { id: 1 } } }));
+    const api: TestApi = {
+      auth: { locale: 'zh-CN' },
+      request: vi.fn(async () => ({ data: { ok: true } })),
+      resource: vi.fn(() => ({ update })),
+    };
+
+    await getWrappedApi(scoped, api)
+      .resource('posts')
+      .update({ filterByTk: 1, values: { title: 't' } });
+
+    expect(root.getDataSourceDirtyVersion('main', 'posts')).toBe(1);
+    expect(scoped.context.engine.getDataSourceDirtyVersion('main', 'posts')).toBe(1);
+  });
+
+  it('should not double-mark when the context exposes a scoped engine proxy', async () => {
+    const root = new FlowEngine();
+    const scoped = createViewScopedEngine(root);
+    const context = new FlowContext();
+    const update = vi.fn(async () => ({ data: { data: { id: 1 } } }));
+    const api: TestApi = {
+      auth: { locale: 'zh-CN' },
+      request: vi.fn(async () => ({ data: { ok: true } })),
+      resource: vi.fn(() => ({ update })),
+    };
+    context.defineProperty('engine', { value: scoped });
+
+    await (getDirtyAwareApiClient(api, context) as TestApi).resource('posts').update({ filterByTk: 1 });
+
+    expect(root.getDataSourceDirtyVersion('main', 'posts')).toBe(1);
+    expect(scoped.getDataSourceDirtyVersion('main', 'posts')).toBe(1);
+  });
+});

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

@@ -0,0 +1,40 @@
+/**
+ * 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 { decodeOpenViewRouteState, encodeOpenViewRouteState, isOpenViewRouteStateToken } from '../openViewRouteState';
+
+describe('openViewRouteState', () => {
+  it('encodes route state as an 8-letter view-bound token', () => {
+    const token = encodeOpenViewRouteState('popup', { mode: 'dialog', size: 'large' });
+
+    expect(token).toMatch(/^[A-Za-z]{8}$/);
+    expect(isOpenViewRouteStateToken(token)).toBe(true);
+    expect(decodeOpenViewRouteState('popup', token)).toEqual({ mode: 'dialog', size: 'large' });
+    expect(decodeOpenViewRouteState('other-popup', token)).toBeUndefined();
+  });
+
+  it('can encode mode without leaking a default size', () => {
+    const token = encodeOpenViewRouteState('popup', { mode: 'embed' });
+
+    expect(token).toMatch(/^[A-Za-z]{8}$/);
+    expect(decodeOpenViewRouteState('popup', token)).toEqual({ mode: 'embed' });
+  });
+
+  it('generates distinct tokens for supported route state combinations', () => {
+    const modes = [undefined, 'drawer', 'dialog', 'embed'] as const;
+    const sizes = [undefined, 'small', 'medium', 'large'] as const;
+    const tokens = modes.flatMap((mode) =>
+      sizes
+        .map((size) => encodeOpenViewRouteState('popup', { mode, size }))
+        .filter((token): token is string => !!token),
+    );
+
+    expect(new Set(tokens).size).toBe(tokens.length);
+  });
+});

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

@@ -8,6 +8,7 @@
  */
 
 import { parsePathnameToViewParams } from '../parsePathnameToViewParams';
+import { encodeOpenViewRouteState } from '../openViewRouteState';
 
 describe('parsePathnameToViewParams', () => {
   test('should return single view param for basic admin path', () => {
@@ -48,6 +49,41 @@ describe('parsePathnameToViewParams', () => {
     expect(result).toEqual([{ viewUid: 'xxx' }, { viewUid: 'yyy', filterByTk: '1', sourceId: '1' }]);
   });
 
+  test('should parse RunJS openView route state without losing route params', () => {
+    const token = encodeOpenViewRouteState('yyy', { mode: 'dialog', size: 'large' });
+    if (!token) {
+      throw new Error('Expected openView route state token.');
+    }
+    const result = parsePathnameToViewParams(`/admin/xxx/view/yyy/opts/${token}/filterbytk/1/sourceid/2`);
+
+    expect(result).toEqual([
+      { viewUid: 'xxx' },
+      {
+        viewUid: 'yyy',
+        openViewRouteState: { mode: 'dialog', size: 'large' },
+        filterByTk: '1',
+        sourceId: '2',
+      },
+    ]);
+  });
+
+  test('should ignore invalid RunJS openView opts and keep following params', () => {
+    const result = parsePathnameToViewParams('/admin/xxx/view/yyy/opts/AbCdEfGh/filterbytk/1');
+
+    expect(result).toEqual([{ viewUid: 'xxx' }, { viewUid: 'yyy', filterByTk: '1' }]);
+  });
+
+  test('should not parse bare RunJS openView route state token segments', () => {
+    const token = encodeOpenViewRouteState('yyy', { mode: 'dialog', size: 'large' });
+    if (!token) {
+      throw new Error('Expected openView route state token.');
+    }
+    const result = parsePathnameToViewParams(`/admin/xxx/view/yyy/${token}/filterbytk/1`);
+
+    expect(result[1]).toMatchObject({ viewUid: 'yyy' });
+    expect(result[1]?.openViewRouteState).toBeUndefined();
+  });
+
   test('should handle multiple views with different filterByTk and sourceId', () => {
     const result = parsePathnameToViewParams(
       '/admin/xxx/view/yyy/filterbytk/1/sourceid/1/view/zzz/filterbytk/2/sourceid/2',