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

package/src/utils/dataSourceDirty.ts

@@ -0,0 +1,126 @@
+/**
+ * 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 { FlowEngine } from '../flowEngine';
+import { DATA_SOURCE_DIRTY_EVENT } from '../views/viewEvents';
+
+type MarkDataSourceDirtyOptions = {
+  engine?: FlowEngine;
+  dataSourceKey?: unknown;
+  resourceName?: unknown;
+  includePreviousEngines?: boolean;
+};
+
+export function getHeaderValue(headers: unknown, name: string): unknown {
+  if (!headers || typeof headers !== 'object') {
+    return undefined;
+  }
+
+  const maybeHeaders = headers as { get?: (key: string) => unknown };
+  if (typeof maybeHeaders.get === 'function') {
+    const value = maybeHeaders.get(name);
+    if (value != null && value !== '') {
+      return value;
+    }
+  }
+
+  const lowerName = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers as Record<string, unknown>)) {
+    if (key.toLowerCase() === lowerName) {
+      return value;
+    }
+  }
+
+  return undefined;
+}
+
+export function getDataSourceKeyFromHeaders(headers: unknown): string {
+  const value = getHeaderValue(headers, 'x-data-source');
+  if (Array.isArray(value)) {
+    return String(value[0] || 'main');
+  }
+  return value == null || value === '' ? 'main' : String(value);
+}
+
+export function getAffectedResourceNames(resourceName: unknown): string[] {
+  const name = String(resourceName || '').trim();
+  if (!name) {
+    return [];
+  }
+
+  const names = new Set<string>([name]);
+  if (name.includes('.')) {
+    names.add(name.split('.')[0]);
+  }
+  return Array.from(names);
+}
+
+function getDirtyTargetEngines(engine: FlowEngine, includePreviousEngines?: boolean): FlowEngine[] {
+  if (!includePreviousEngines) {
+    return [engine];
+  }
+
+  const engines: FlowEngine[] = [];
+  const seen = new Set<FlowEngine>();
+  let current: FlowEngine | undefined = engine;
+  let guard = 0;
+
+  while (current && guard++ < 50) {
+    if (!seen.has(current)) {
+      engines.push(current);
+      seen.add(current);
+    }
+    current = current.previousEngine;
+  }
+
+  return engines;
+}
+
+export function markDataSourceDirty(options: MarkDataSourceDirtyOptions): string[] {
+  const { engine, resourceName, includePreviousEngines } = options;
+  if (!engine?.markDataSourceDirty) {
+    return [];
+  }
+
+  const resourceNames = getAffectedResourceNames(resourceName);
+  if (!resourceNames.length) {
+    return [];
+  }
+
+  const dataSourceKey = String(options.dataSourceKey || 'main');
+  const targetEngines = getDirtyTargetEngines(engine, includePreviousEngines);
+  const beforeVersions = new Map<FlowEngine, Map<string, number>>();
+
+  for (const targetEngine of targetEngines) {
+    const versions = new Map<string, number>();
+    beforeVersions.set(targetEngine, versions);
+    for (const name of resourceNames) {
+      versions.set(name, targetEngine.getDataSourceDirtyVersion?.(dataSourceKey, name) || 0);
+    }
+  }
+
+  for (const targetEngine of targetEngines) {
+    const versions = beforeVersions.get(targetEngine);
+    for (const name of resourceNames) {
+      const before = versions?.get(name) || 0;
+      const current = targetEngine.getDataSourceDirtyVersion?.(dataSourceKey, name) || 0;
+      if (current !== before) {
+        continue;
+      }
+      targetEngine.markDataSourceDirty(dataSourceKey, name);
+    }
+  }
+
+  engine.emitter?.emit?.(DATA_SOURCE_DIRTY_EVENT, {
+    dataSourceKey,
+    resourceNames,
+  });
+
+  return resourceNames;
+}

package/src/utils/dirtyAwareApiClient.ts

@@ -0,0 +1,430 @@
+/**
+ * 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 { ActionParams, APIClient, IResource, RequestOptions } from '@nocobase/sdk';
+import type { FlowContext } from '../flowContext';
+import { getDataSourceKeyFromHeaders, markDataSourceDirty } from './dataSourceDirty';
+
+type ResourceActionFn = (params?: ActionParams, opts?: unknown) => Promise<unknown>;
+
+export const SKIP_DATA_SOURCE_DIRTY = '__nocobaseSkipDataSourceDirty';
+
+type ResourceRequestOptions = RequestOptions & {
+  resource?: unknown;
+  resourceOf?: unknown;
+  action?: unknown;
+  headers?: unknown;
+  [SKIP_DATA_SOURCE_DIRTY]?: boolean;
+};
+
+type DirtyResourceAction = {
+  dataSourceKey?: string;
+  resourceName: string;
+  actionName: string;
+};
+
+type ApiUrlProvider = {
+  getApiUrl?: (pathname?: string) => string;
+};
+
+type DirtyAwareAPIClient = APIClient & {
+  resource: APIClient['resource'];
+  request: APIClient['request'];
+};
+
+type APIClientRequestConfig = Parameters<APIClient['request']>[0];
+
+const dirtyAwareApiClientCache = new WeakMap<object, WeakMap<object, APIClient>>();
+const dirtyAwareApiClientProxies = new WeakSet<object>();
+
+const MUTATING_RESOURCE_ACTIONS = [
+  'add',
+  'bulkdestroy',
+  'bulkupdate',
+  'create',
+  'delete',
+  'destroy',
+  'execute',
+  'firstorcreate',
+  'import',
+  'move',
+  'remove',
+  'save',
+  'saveastemplate',
+  'set',
+  'setfields',
+  'submit',
+  'update',
+  'updateorcreate',
+  'upsert',
+];
+
+function isApiClientLike(value: unknown): value is DirtyAwareAPIClient {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  const candidate = value as { resource?: unknown; request?: unknown };
+  return typeof candidate.resource === 'function' && typeof candidate.request === 'function';
+}
+
+function isMutatingResourceAction(actionName: string): boolean {
+  const normalized = String(actionName || '').trim();
+  if (!normalized) {
+    return false;
+  }
+  const baseActionName = normalized.split('/')[0];
+  const lowerBaseActionName = baseActionName.toLowerCase();
+  return MUTATING_RESOURCE_ACTIONS.some((action) => {
+    if (lowerBaseActionName === action) {
+      return true;
+    }
+    if (!lowerBaseActionName.startsWith(action) || baseActionName.length <= action.length) {
+      return false;
+    }
+
+    const nextChar = baseActionName[action.length];
+    return nextChar === '-' || nextChar === '_' || (nextChar >= 'A' && nextChar <= 'Z');
+  });
+}
+
+function getCurrentOrigin(): string | undefined {
+  return typeof window === 'undefined' ? undefined : window.location?.origin;
+}
+
+function parseUrl(value: string, base?: string): URL | undefined {
+  try {
+    return new URL(value, base);
+  } catch {
+    return undefined;
+  }
+}
+
+function stripSearchAndHash(path: string): string {
+  const index = path.search(/[?#]/);
+  return index === -1 ? path : path.slice(0, index);
+}
+
+function stripKnownApiPrefix(path: string): string | undefined {
+  const cleanPath = stripSearchAndHash(path).trim();
+  if (!cleanPath) {
+    return undefined;
+  }
+
+  const normalizedPath = cleanPath.replace(/^\/+/, '');
+  if (!normalizedPath || normalizedPath === 'api') {
+    return undefined;
+  }
+  if (normalizedPath.startsWith('api/')) {
+    return normalizedPath.slice('api/'.length);
+  }
+
+  return normalizedPath;
+}
+
+function normalizePathname(pathname: string) {
+  return pathname.endsWith('/') ? pathname : `${pathname}/`;
+}
+
+function getAppApiUrl(app?: ApiUrlProvider): URL | undefined {
+  if (!app?.getApiUrl) {
+    return undefined;
+  }
+
+  try {
+    return parseUrl(app.getApiUrl(), getCurrentOrigin());
+  } catch {
+    return undefined;
+  }
+}
+
+function stripConfiguredApiPrefix(path: string, apiPathname: string): string | undefined {
+  const cleanPath = stripSearchAndHash(path).trim();
+  if (!cleanPath.startsWith('/')) {
+    return undefined;
+  }
+
+  const apiPath = normalizePathname(apiPathname);
+  const requestPath = normalizePathname(cleanPath);
+  if (!requestPath.startsWith(apiPath)) {
+    return undefined;
+  }
+
+  const apiPathWithoutTrailingSlash = apiPath.replace(/\/$/, '');
+  return cleanPath.slice(apiPathWithoutTrailingSlash.length).replace(/^\/+/, '') || undefined;
+}
+
+function getDirtyResourcePathFromAbsoluteUrl(url: URL, app?: ApiUrlProvider): string | undefined {
+  if (!['http:', 'https:'].includes(url.protocol)) {
+    return undefined;
+  }
+
+  if (app?.getApiUrl) {
+    const apiUrl = getAppApiUrl(app);
+    if (!apiUrl || url.origin !== apiUrl.origin) {
+      return undefined;
+    }
+
+    return stripConfiguredApiPrefix(url.pathname, apiUrl.pathname);
+  }
+
+  const currentOrigin = getCurrentOrigin();
+  if (!currentOrigin || url.origin !== currentOrigin) {
+    return undefined;
+  }
+
+  return stripKnownApiPrefix(url.pathname);
+}
+
+function getDirtyResourcePathFromUrl(url: unknown, context: FlowContext): string | undefined {
+  if (typeof url !== 'string') {
+    return undefined;
+  }
+
+  const trimmedUrl = url.trim();
+  if (!trimmedUrl || trimmedUrl.startsWith('//')) {
+    return undefined;
+  }
+
+  if (/^https?:\/\//i.test(trimmedUrl)) {
+    const parsedUrl = parseUrl(trimmedUrl);
+    if (!parsedUrl) {
+      return undefined;
+    }
+    return getDirtyResourcePathFromAbsoluteUrl(parsedUrl, context.app as ApiUrlProvider | undefined);
+  }
+
+  const appApiUrl = getAppApiUrl(context.app as ApiUrlProvider | undefined);
+  const configuredResourcePath = appApiUrl ? stripConfiguredApiPrefix(trimmedUrl, appApiUrl.pathname) : undefined;
+  if (configuredResourcePath) {
+    return configuredResourcePath;
+  }
+
+  return stripKnownApiPrefix(trimmedUrl);
+}
+
+function decodeResourcePathSegment(segment: string): string {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+
+function getDataSourceKeyFromResourceOf(resourceOf: unknown): string | undefined {
+  const dataSourceKey = String(resourceOf ?? '').trim();
+  return dataSourceKey || undefined;
+}
+
+function parseResourceActionFromSegments(segments: string[]): DirtyResourceAction | undefined {
+  const resourceSegments: string[] = [];
+  let actionName: string | undefined;
+  let actionSegmentIndex = -1;
+
+  for (let index = 0; index < segments.length; index += 2) {
+    const segment = segments[index];
+    const actionDelimiterIndex = segment.lastIndexOf(':');
+    const resourceSegment = actionDelimiterIndex === -1 ? segment : segment.slice(0, actionDelimiterIndex);
+    if (!resourceSegment) {
+      return undefined;
+    }
+
+    resourceSegments.push(decodeResourcePathSegment(resourceSegment));
+    if (actionDelimiterIndex !== -1) {
+      actionName = decodeResourcePathSegment(segment.slice(actionDelimiterIndex + 1)).trim();
+      actionSegmentIndex = index;
+      break;
+    }
+  }
+
+  if (!actionName || !resourceSegments.length) {
+    return undefined;
+  }
+
+  if (segments.length > actionSegmentIndex + 2) {
+    return undefined;
+  }
+
+  return {
+    resourceName: resourceSegments.join('.'),
+    actionName,
+  };
+}
+
+function parseDirtyResourceActionFromUrl(url: unknown, context: FlowContext): DirtyResourceAction | undefined {
+  const resourcePath = getDirtyResourcePathFromUrl(url, context);
+  if (!resourcePath) {
+    return undefined;
+  }
+
+  const segments = stripSearchAndHash(resourcePath).split('/').filter(Boolean);
+  const firstSegment = decodeResourcePathSegment(segments[0] || '');
+  if (firstSegment === 'dataSources' && segments.length >= 3) {
+    const dataSourceKey = getDataSourceKeyFromResourceOf(decodeResourcePathSegment(segments[1]));
+    const parsed = parseResourceActionFromSegments(segments.slice(2));
+    if (dataSourceKey && parsed) {
+      return {
+        ...parsed,
+        dataSourceKey,
+      };
+    }
+  }
+
+  return parseResourceActionFromSegments(segments);
+}
+
+function resolveDirtyResourceActionFromResource(
+  resourceName: string,
+  resourceOf: unknown,
+  actionName: string,
+  context: FlowContext,
+): DirtyResourceAction | undefined {
+  const normalizedResourceName = resourceName.trim();
+  const normalizedActionName = actionName.trim();
+  if (!normalizedResourceName || !normalizedActionName) {
+    return undefined;
+  }
+
+  if (normalizedResourceName.includes('/')) {
+    const parsed = parseDirtyResourceActionFromUrl(`${normalizedResourceName}:${normalizedActionName}`, context);
+    if (parsed) {
+      return parsed;
+    }
+  }
+
+  const dataSourcesPrefix = 'dataSources.';
+  if (normalizedResourceName.startsWith(dataSourcesPrefix)) {
+    const dataSourceKey = getDataSourceKeyFromResourceOf(resourceOf);
+    const nestedResourceName = normalizedResourceName.slice(dataSourcesPrefix.length).trim();
+    if (dataSourceKey && nestedResourceName) {
+      return {
+        dataSourceKey,
+        resourceName: nestedResourceName,
+        actionName: normalizedActionName,
+      };
+    }
+  }
+
+  return {
+    resourceName: normalizedResourceName,
+    actionName: normalizedActionName,
+  };
+}
+
+function resolveDirtyResourceAction(
+  options: ResourceRequestOptions,
+  context: FlowContext,
+): DirtyResourceAction | undefined {
+  const resourceName = typeof options?.resource === 'string' ? options.resource : undefined;
+  const actionName = typeof options?.action === 'string' ? options.action : undefined;
+  if (resourceName && actionName) {
+    return resolveDirtyResourceActionFromResource(resourceName, options.resourceOf, actionName, context);
+  }
+
+  return parseDirtyResourceActionFromUrl(options?.url, context);
+}
+
+function markResourceActionDataSourceDirty(
+  context: FlowContext,
+  dirtyResourceAction: DirtyResourceAction,
+  headers: unknown,
+) {
+  markDataSourceDirty({
+    engine: context.engine,
+    dataSourceKey: dirtyResourceAction.dataSourceKey || getDataSourceKeyFromHeaders(headers),
+    resourceName: dirtyResourceAction.resourceName,
+    includePreviousEngines: true,
+  });
+}
+
+function createDirtyAwareResource(
+  context: FlowContext,
+  resource: IResource,
+  resourceName: string,
+  resourceOf: unknown,
+  headers: unknown,
+): IResource {
+  return new Proxy(resource, {
+    get(target, prop, receiver) {
+      const original = Reflect.get(target, prop, receiver);
+      if (typeof prop !== 'string' || typeof original !== 'function' || !isMutatingResourceAction(prop)) {
+        return original;
+      }
+
+      const action = original as ResourceActionFn;
+      return async (...args: Parameters<ResourceActionFn>) => {
+        const result = await action(...args);
+        const dirtyResourceAction = resolveDirtyResourceActionFromResource(resourceName, resourceOf, prop, context);
+        if (dirtyResourceAction) {
+          markResourceActionDataSourceDirty(context, dirtyResourceAction, headers);
+        }
+        return result;
+      };
+    },
+  });
+}
+
+function createDirtyAwareApiClient(api: DirtyAwareAPIClient, context: FlowContext): APIClient {
+  const resource: APIClient['resource'] = (name, of, headers, cancel) => {
+    const targetResource = api.resource(name, of, headers, cancel);
+    return createDirtyAwareResource(context, targetResource, name, of, headers);
+  };
+
+  const request = (<T, R, D>(config: APIClientRequestConfig): Promise<R> => {
+    const options = config as ResourceRequestOptions;
+    const skipDataSourceDirty = options?.[SKIP_DATA_SOURCE_DIRTY];
+    const dirtyResourceAction = skipDataSourceDirty ? undefined : resolveDirtyResourceAction(options, context);
+    const { [SKIP_DATA_SOURCE_DIRTY]: _skipDataSourceDirty, ...cleanConfig } = options;
+    return api.request<T, R, D>(cleanConfig as typeof config).then((result) => {
+      if (dirtyResourceAction && isMutatingResourceAction(dirtyResourceAction.actionName)) {
+        markResourceActionDataSourceDirty(context, dirtyResourceAction, options.headers);
+      }
+      return result;
+    });
+  }) as APIClient['request'];
+
+  const proxy = new Proxy(api, {
+    get(target, prop, receiver) {
+      if (prop === 'resource') {
+        return resource;
+      }
+      if (prop === 'request') {
+        return request;
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+  }) as APIClient;
+  dirtyAwareApiClientProxies.add(proxy);
+  return proxy;
+}
+
+export function getDirtyAwareApiClient(value: unknown, context: FlowContext): unknown {
+  if (!isApiClientLike(value)) {
+    return value;
+  }
+
+  if (dirtyAwareApiClientProxies.has(value)) {
+    return value;
+  }
+
+  const api = value as unknown as APIClient;
+  let contextCache = dirtyAwareApiClientCache.get(api);
+  if (!contextCache) {
+    contextCache = new WeakMap<object, APIClient>();
+    dirtyAwareApiClientCache.set(api, contextCache);
+  }
+
+  const cached = contextCache.get(context);
+  if (cached) {
+    return cached;
+  }
+
+  const wrapped = createDirtyAwareApiClient(value, context);
+  contextCache.set(context, wrapped);
+  return wrapped;
+}

package/src/utils/index.ts

@@ -66,6 +66,16 @@ export { extractPropertyPath, formatPathToVariable, isVariableExpression } from
 
 export { clearAutoFlowError, getAutoFlowError, setAutoFlowError, type AutoFlowError } from './autoFlowError';
 export { parsePathnameToViewParams, type ViewParam } from './parsePathnameToViewParams';
+export {
+  createOpenViewRouteState,
+  decodeOpenViewRouteState,
+  encodeOpenViewRouteState,
+  isOpenViewRouteStateToken,
+  RUNJS_OPEN_VIEW_ROUTE_STATE,
+  type OpenViewRouteMode,
+  type OpenViewRouteSize,
+  type OpenViewRouteState,
+} from './openViewRouteState';
 export {
   decodeBase64Url,
   encodeBase64Url,
@@ -77,15 +87,6 @@ export {
   serializeCtxDateValue,
 } from './dateVariable';
 
-// 安全全局对象（window/document）
-export {
-  createSafeDocument,
-  createSafeWindow,
-  createSafeNavigator,
-  createSafeRunJSGlobals,
-  runjsWithSafeGlobals,
-} from './safeGlobals';
-
 // RunJS value helpers
 export { isRunJSValue, normalizeRunJSValue, extractUsedVariablePathsFromRunJS, type RunJSValue } from './runjsValue';
 

package/src/utils/openViewRouteState.ts

@@ -0,0 +1,107 @@
+/**
+ * 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.
+ */
+
+const OPEN_VIEW_ROUTE_MODES = ['drawer', 'dialog', 'embed'] as const;
+const OPEN_VIEW_ROUTE_SIZES = ['small', 'medium', 'large'] as const;
+const OPEN_VIEW_ROUTE_STATE_TOKEN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const OPEN_VIEW_ROUTE_STATE_TOKEN_LENGTH = 8;
+
+export type OpenViewRouteMode = (typeof OPEN_VIEW_ROUTE_MODES)[number];
+export type OpenViewRouteSize = (typeof OPEN_VIEW_ROUTE_SIZES)[number];
+
+export type OpenViewRouteState = {
+  mode?: OpenViewRouteMode;
+  size?: OpenViewRouteSize;
+};
+
+export const RUNJS_OPEN_VIEW_ROUTE_STATE = Symbol.for('nocobase.runjs.openViewRouteState');
+
+function isOpenViewRouteMode(value: unknown): value is OpenViewRouteMode {
+  return typeof value === 'string' && (OPEN_VIEW_ROUTE_MODES as readonly string[]).includes(value);
+}
+
+function isOpenViewRouteSize(value: unknown): value is OpenViewRouteSize {
+  return typeof value === 'string' && (OPEN_VIEW_ROUTE_SIZES as readonly string[]).includes(value);
+}
+
+export function createOpenViewRouteState(input?: { mode?: unknown; size?: unknown }): OpenViewRouteState | undefined {
+  const state: OpenViewRouteState = {};
+
+  if (isOpenViewRouteMode(input?.mode)) {
+    state.mode = input.mode;
+  }
+  if (isOpenViewRouteSize(input?.size)) {
+    state.size = input.size;
+  }
+
+  return state.mode || state.size ? state : undefined;
+}
+
+function hashString(value: string) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+function stateToCode(state: OpenViewRouteState) {
+  const modeIndex = state.mode ? OPEN_VIEW_ROUTE_MODES.indexOf(state.mode) + 1 : 0;
+  const sizeIndex = state.size ? OPEN_VIEW_ROUTE_SIZES.indexOf(state.size) + 1 : 0;
+  const code = modeIndex * 4 + sizeIndex;
+  return code > 0 ? code : undefined;
+}
+
+function codeToState(code: number): OpenViewRouteState | undefined {
+  const modeIndex = Math.floor(code / 4);
+  const sizeIndex = code % 4;
+  return createOpenViewRouteState({
+    mode: modeIndex ? OPEN_VIEW_ROUTE_MODES[modeIndex - 1] : undefined,
+    size: sizeIndex ? OPEN_VIEW_ROUTE_SIZES[sizeIndex - 1] : undefined,
+  });
+}
+
+function tokenForCode(viewUid: string, code: number) {
+  let seed = hashString(`${viewUid}:${code}`);
+  let token = '';
+  for (let i = 0; i < OPEN_VIEW_ROUTE_STATE_TOKEN_LENGTH; i++) {
+    seed = Math.imul(seed ^ (code + i * 17), 16777619) >>> 0;
+    token += OPEN_VIEW_ROUTE_STATE_TOKEN_ALPHABET[seed % OPEN_VIEW_ROUTE_STATE_TOKEN_ALPHABET.length];
+  }
+  return token;
+}
+
+export function isOpenViewRouteStateToken(value: unknown): value is string {
+  return (
+    typeof value === 'string' &&
+    value.length === OPEN_VIEW_ROUTE_STATE_TOKEN_LENGTH &&
+    [...value].every((char) => OPEN_VIEW_ROUTE_STATE_TOKEN_ALPHABET.includes(char))
+  );
+}
+
+export function encodeOpenViewRouteState(viewUid: string, input?: { mode?: unknown; size?: unknown }) {
+  const state = createOpenViewRouteState(input);
+  const code = state ? stateToCode(state) : undefined;
+  return code ? tokenForCode(viewUid, code) : undefined;
+}
+
+export function decodeOpenViewRouteState(viewUid: string, token: unknown) {
+  if (!isOpenViewRouteStateToken(token)) {
+    return undefined;
+  }
+
+  for (let code = 1; code < 16; code++) {
+    if (tokenForCode(viewUid, code) === token) {
+      return codeToState(code);
+    }
+  }
+
+  return undefined;
+}