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

package/lib/utils/dirtyAwareApiClient.js

@@ -0,0 +1,378 @@
+/**
+ * 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 dirtyAwareApiClient_exports = {};
+__export(dirtyAwareApiClient_exports, {
+  SKIP_DATA_SOURCE_DIRTY: () => SKIP_DATA_SOURCE_DIRTY,
+  getDirtyAwareApiClient: () => getDirtyAwareApiClient
+});
+module.exports = __toCommonJS(dirtyAwareApiClient_exports);
+var import_dataSourceDirty = require("./dataSourceDirty");
+const SKIP_DATA_SOURCE_DIRTY = "__nocobaseSkipDataSourceDirty";
+const dirtyAwareApiClientCache = /* @__PURE__ */ new WeakMap();
+const dirtyAwareApiClientProxies = /* @__PURE__ */ new WeakSet();
+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) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.resource === "function" && typeof candidate.request === "function";
+}
+__name(isApiClientLike, "isApiClientLike");
+function isMutatingResourceAction(actionName) {
+  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";
+  });
+}
+__name(isMutatingResourceAction, "isMutatingResourceAction");
+function getCurrentOrigin() {
+  var _a;
+  return typeof window === "undefined" ? void 0 : (_a = window.location) == null ? void 0 : _a.origin;
+}
+__name(getCurrentOrigin, "getCurrentOrigin");
+function parseUrl(value, base) {
+  try {
+    return new URL(value, base);
+  } catch {
+    return void 0;
+  }
+}
+__name(parseUrl, "parseUrl");
+function stripSearchAndHash(path) {
+  const index = path.search(/[?#]/);
+  return index === -1 ? path : path.slice(0, index);
+}
+__name(stripSearchAndHash, "stripSearchAndHash");
+function stripKnownApiPrefix(path) {
+  const cleanPath = stripSearchAndHash(path).trim();
+  if (!cleanPath) {
+    return void 0;
+  }
+  const normalizedPath = cleanPath.replace(/^\/+/, "");
+  if (!normalizedPath || normalizedPath === "api") {
+    return void 0;
+  }
+  if (normalizedPath.startsWith("api/")) {
+    return normalizedPath.slice("api/".length);
+  }
+  return normalizedPath;
+}
+__name(stripKnownApiPrefix, "stripKnownApiPrefix");
+function normalizePathname(pathname) {
+  return pathname.endsWith("/") ? pathname : `${pathname}/`;
+}
+__name(normalizePathname, "normalizePathname");
+function getAppApiUrl(app) {
+  if (!(app == null ? void 0 : app.getApiUrl)) {
+    return void 0;
+  }
+  try {
+    return parseUrl(app.getApiUrl(), getCurrentOrigin());
+  } catch {
+    return void 0;
+  }
+}
+__name(getAppApiUrl, "getAppApiUrl");
+function stripConfiguredApiPrefix(path, apiPathname) {
+  const cleanPath = stripSearchAndHash(path).trim();
+  if (!cleanPath.startsWith("/")) {
+    return void 0;
+  }
+  const apiPath = normalizePathname(apiPathname);
+  const requestPath = normalizePathname(cleanPath);
+  if (!requestPath.startsWith(apiPath)) {
+    return void 0;
+  }
+  const apiPathWithoutTrailingSlash = apiPath.replace(/\/$/, "");
+  return cleanPath.slice(apiPathWithoutTrailingSlash.length).replace(/^\/+/, "") || void 0;
+}
+__name(stripConfiguredApiPrefix, "stripConfiguredApiPrefix");
+function getDirtyResourcePathFromAbsoluteUrl(url, app) {
+  if (!["http:", "https:"].includes(url.protocol)) {
+    return void 0;
+  }
+  if (app == null ? void 0 : app.getApiUrl) {
+    const apiUrl = getAppApiUrl(app);
+    if (!apiUrl || url.origin !== apiUrl.origin) {
+      return void 0;
+    }
+    return stripConfiguredApiPrefix(url.pathname, apiUrl.pathname);
+  }
+  const currentOrigin = getCurrentOrigin();
+  if (!currentOrigin || url.origin !== currentOrigin) {
+    return void 0;
+  }
+  return stripKnownApiPrefix(url.pathname);
+}
+__name(getDirtyResourcePathFromAbsoluteUrl, "getDirtyResourcePathFromAbsoluteUrl");
+function getDirtyResourcePathFromUrl(url, context) {
+  if (typeof url !== "string") {
+    return void 0;
+  }
+  const trimmedUrl = url.trim();
+  if (!trimmedUrl || trimmedUrl.startsWith("//")) {
+    return void 0;
+  }
+  if (/^https?:\/\//i.test(trimmedUrl)) {
+    const parsedUrl = parseUrl(trimmedUrl);
+    if (!parsedUrl) {
+      return void 0;
+    }
+    return getDirtyResourcePathFromAbsoluteUrl(parsedUrl, context.app);
+  }
+  const appApiUrl = getAppApiUrl(context.app);
+  const configuredResourcePath = appApiUrl ? stripConfiguredApiPrefix(trimmedUrl, appApiUrl.pathname) : void 0;
+  if (configuredResourcePath) {
+    return configuredResourcePath;
+  }
+  return stripKnownApiPrefix(trimmedUrl);
+}
+__name(getDirtyResourcePathFromUrl, "getDirtyResourcePathFromUrl");
+function decodeResourcePathSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+__name(decodeResourcePathSegment, "decodeResourcePathSegment");
+function getDataSourceKeyFromResourceOf(resourceOf) {
+  const dataSourceKey = String(resourceOf ?? "").trim();
+  return dataSourceKey || void 0;
+}
+__name(getDataSourceKeyFromResourceOf, "getDataSourceKeyFromResourceOf");
+function parseResourceActionFromSegments(segments) {
+  const resourceSegments = [];
+  let actionName;
+  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 void 0;
+    }
+    resourceSegments.push(decodeResourcePathSegment(resourceSegment));
+    if (actionDelimiterIndex !== -1) {
+      actionName = decodeResourcePathSegment(segment.slice(actionDelimiterIndex + 1)).trim();
+      actionSegmentIndex = index;
+      break;
+    }
+  }
+  if (!actionName || !resourceSegments.length) {
+    return void 0;
+  }
+  if (segments.length > actionSegmentIndex + 2) {
+    return void 0;
+  }
+  return {
+    resourceName: resourceSegments.join("."),
+    actionName
+  };
+}
+__name(parseResourceActionFromSegments, "parseResourceActionFromSegments");
+function parseDirtyResourceActionFromUrl(url, context) {
+  const resourcePath = getDirtyResourcePathFromUrl(url, context);
+  if (!resourcePath) {
+    return void 0;
+  }
+  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);
+}
+__name(parseDirtyResourceActionFromUrl, "parseDirtyResourceActionFromUrl");
+function resolveDirtyResourceActionFromResource(resourceName, resourceOf, actionName, context) {
+  const normalizedResourceName = resourceName.trim();
+  const normalizedActionName = actionName.trim();
+  if (!normalizedResourceName || !normalizedActionName) {
+    return void 0;
+  }
+  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
+  };
+}
+__name(resolveDirtyResourceActionFromResource, "resolveDirtyResourceActionFromResource");
+function resolveDirtyResourceAction(options, context) {
+  const resourceName = typeof (options == null ? void 0 : options.resource) === "string" ? options.resource : void 0;
+  const actionName = typeof (options == null ? void 0 : options.action) === "string" ? options.action : void 0;
+  if (resourceName && actionName) {
+    return resolveDirtyResourceActionFromResource(resourceName, options.resourceOf, actionName, context);
+  }
+  return parseDirtyResourceActionFromUrl(options == null ? void 0 : options.url, context);
+}
+__name(resolveDirtyResourceAction, "resolveDirtyResourceAction");
+function markResourceActionDataSourceDirty(context, dirtyResourceAction, headers) {
+  (0, import_dataSourceDirty.markDataSourceDirty)({
+    engine: context.engine,
+    dataSourceKey: dirtyResourceAction.dataSourceKey || (0, import_dataSourceDirty.getDataSourceKeyFromHeaders)(headers),
+    resourceName: dirtyResourceAction.resourceName,
+    includePreviousEngines: true
+  });
+}
+__name(markResourceActionDataSourceDirty, "markResourceActionDataSourceDirty");
+function createDirtyAwareResource(context, resource, resourceName, resourceOf, headers) {
+  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;
+      return async (...args) => {
+        const result = await action(...args);
+        const dirtyResourceAction = resolveDirtyResourceActionFromResource(resourceName, resourceOf, prop, context);
+        if (dirtyResourceAction) {
+          markResourceActionDataSourceDirty(context, dirtyResourceAction, headers);
+        }
+        return result;
+      };
+    }
+  });
+}
+__name(createDirtyAwareResource, "createDirtyAwareResource");
+function createDirtyAwareApiClient(api, context) {
+  const resource = /* @__PURE__ */ __name((name, of, headers, cancel) => {
+    const targetResource = api.resource(name, of, headers, cancel);
+    return createDirtyAwareResource(context, targetResource, name, of, headers);
+  }, "resource");
+  const request = /* @__PURE__ */ __name((config) => {
+    const options = config;
+    const skipDataSourceDirty = options == null ? void 0 : options[SKIP_DATA_SOURCE_DIRTY];
+    const dirtyResourceAction = skipDataSourceDirty ? void 0 : resolveDirtyResourceAction(options, context);
+    const { [SKIP_DATA_SOURCE_DIRTY]: _skipDataSourceDirty, ...cleanConfig } = options;
+    return api.request(cleanConfig).then((result) => {
+      if (dirtyResourceAction && isMutatingResourceAction(dirtyResourceAction.actionName)) {
+        markResourceActionDataSourceDirty(context, dirtyResourceAction, options.headers);
+      }
+      return result;
+    });
+  }, "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);
+    }
+  });
+  dirtyAwareApiClientProxies.add(proxy);
+  return proxy;
+}
+__name(createDirtyAwareApiClient, "createDirtyAwareApiClient");
+function getDirtyAwareApiClient(value, context) {
+  if (!isApiClientLike(value)) {
+    return value;
+  }
+  if (dirtyAwareApiClientProxies.has(value)) {
+    return value;
+  }
+  const api = value;
+  let contextCache = dirtyAwareApiClientCache.get(api);
+  if (!contextCache) {
+    contextCache = /* @__PURE__ */ new WeakMap();
+    dirtyAwareApiClientCache.set(api, contextCache);
+  }
+  const cached = contextCache.get(context);
+  if (cached) {
+    return cached;
+  }
+  const wrapped = createDirtyAwareApiClient(value, context);
+  contextCache.set(context, wrapped);
+  return wrapped;
+}
+__name(getDirtyAwareApiClient, "getDirtyAwareApiClient");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SKIP_DATA_SOURCE_DIRTY,
+  getDirtyAwareApiClient
+});

package/lib/utils/index.d.ts

@@ -20,8 +20,8 @@ export { buildRecordMeta, collectContextParamsForTemplate, createCurrentRecordMe
 export { extractPropertyPath, formatPathToVariable, isVariableExpression } from './context';
 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, isCompleteCtxDatePath, isCtxDatePathPrefix, isCtxDateExpression, parseCtxDateExpression, resolveCtxDatePath, serializeCtxDateValue, } from './dateVariable';
-export { createSafeDocument, createSafeWindow, createSafeNavigator, createSafeRunJSGlobals, runjsWithSafeGlobals, } from './safeGlobals';
 export { isRunJSValue, normalizeRunJSValue, extractUsedVariablePathsFromRunJS, type RunJSValue } from './runjsValue';
 export { resolveRunJSObjectValues } from './resolveRunJSObjectValues';
 export { prepareRunJsCode, preprocessRunJsTemplates } from './runjsTemplateCompat';

package/lib/utils/index.js

@@ -33,6 +33,7 @@ __export(utils_exports, {
   FlowExitAllException: () => import_exceptions.FlowExitAllException,
   FlowExitException: () => import_exceptions.FlowExitException,
   MENU_KEYS: () => import_constants.MENU_KEYS,
+  RUNJS_OPEN_VIEW_ROUTE_STATE: () => import_openViewRouteState.RUNJS_OPEN_VIEW_ROUTE_STATE,
   buildRecordMeta: () => import_variablesParams.buildRecordMeta,
   clearAutoFlowError: () => import_autoFlowError.clearAutoFlowError,
   collectContextParamsForTemplate: () => import_variablesParams.collectContextParamsForTemplate,
@@ -42,15 +43,14 @@ __export(utils_exports, {
   createCollectionContextMeta: () => import_createCollectionContextMeta.createCollectionContextMeta,
   createCurrentRecordMetaFactory: () => import_variablesParams.createCurrentRecordMetaFactory,
   createEphemeralContext: () => import_createEphemeralContext.createEphemeralContext,
+  createOpenViewRouteState: () => import_openViewRouteState.createOpenViewRouteState,
   createRecordMetaFactory: () => import_variablesParams.createRecordMetaFactory,
   createRecordResolveOnServerWithLocal: () => import_variablesParams.createRecordResolveOnServerWithLocal,
-  createSafeDocument: () => import_safeGlobals.createSafeDocument,
-  createSafeNavigator: () => import_safeGlobals.createSafeNavigator,
-  createSafeRunJSGlobals: () => import_safeGlobals.createSafeRunJSGlobals,
-  createSafeWindow: () => import_safeGlobals.createSafeWindow,
   decodeBase64Url: () => import_dateVariable.decodeBase64Url,
+  decodeOpenViewRouteState: () => import_openViewRouteState.decodeOpenViewRouteState,
   defineAction: () => import_flow_definitions.defineAction,
   encodeBase64Url: () => import_dateVariable.encodeBase64Url,
+  encodeOpenViewRouteState: () => import_openViewRouteState.encodeOpenViewRouteState,
   escapeT: () => import_translation.escapeT,
   extractPropertyPath: () => import_context.extractPropertyPath,
   extractUsedVariableNames: () => import_variablesParams.extractUsedVariableNames,
@@ -66,6 +66,7 @@ __export(utils_exports, {
   isCtxDateExpression: () => import_dateVariable.isCtxDateExpression,
   isCtxDatePathPrefix: () => import_dateVariable.isCtxDatePathPrefix,
   isInheritedFrom: () => import_inheritance.isInheritedFrom,
+  isOpenViewRouteStateToken: () => import_openViewRouteState.isOpenViewRouteStateToken,
   isRunJSValue: () => import_runjsValue.isRunJSValue,
   isVariableExpression: () => import_context.isVariableExpression,
   normalizeRunJSValue: () => import_runjsValue.normalizeRunJSValue,
@@ -84,7 +85,6 @@ __export(utils_exports, {
   resolveStepDisabledInSettings: () => import_schema_utils.resolveStepDisabledInSettings,
   resolveStepUiSchema: () => import_schema_utils.resolveStepUiSchema,
   resolveUiMode: () => import_schema_utils.resolveUiMode,
-  runjsWithSafeGlobals: () => import_safeGlobals.runjsWithSafeGlobals,
   serializeCtxDateValue: () => import_dateVariable.serializeCtxDateValue,
   setAutoFlowError: () => import_autoFlowError.setAutoFlowError,
   setupRuntimeContextSteps: () => import_setupRuntimeContextSteps.setupRuntimeContextSteps,
@@ -107,8 +107,8 @@ var import_variablesParams = require("./variablesParams");
 var import_context = require("./context");
 var import_autoFlowError = require("./autoFlowError");
 var import_parsePathnameToViewParams = require("./parsePathnameToViewParams");
+var import_openViewRouteState = require("./openViewRouteState");
 var import_dateVariable = require("./dateVariable");
-var import_safeGlobals = require("./safeGlobals");
 var import_runjsValue = require("./runjsValue");
 var import_resolveRunJSObjectValues = require("./resolveRunJSObjectValues");
 var import_runjsTemplateCompat = require("./runjsTemplateCompat");
@@ -126,6 +126,7 @@ var import_randomId = require("./randomId");
   FlowExitAllException,
   FlowExitException,
   MENU_KEYS,
+  RUNJS_OPEN_VIEW_ROUTE_STATE,
   buildRecordMeta,
   clearAutoFlowError,
   collectContextParamsForTemplate,
@@ -135,15 +136,14 @@ var import_randomId = require("./randomId");
   createCollectionContextMeta,
   createCurrentRecordMetaFactory,
   createEphemeralContext,
+  createOpenViewRouteState,
   createRecordMetaFactory,
   createRecordResolveOnServerWithLocal,
-  createSafeDocument,
-  createSafeNavigator,
-  createSafeRunJSGlobals,
-  createSafeWindow,
   decodeBase64Url,
+  decodeOpenViewRouteState,
   defineAction,
   encodeBase64Url,
+  encodeOpenViewRouteState,
   escapeT,
   extractPropertyPath,
   extractUsedVariableNames,
@@ -159,6 +159,7 @@ var import_randomId = require("./randomId");
   isCtxDateExpression,
   isCtxDatePathPrefix,
   isInheritedFrom,
+  isOpenViewRouteStateToken,
   isRunJSValue,
   isVariableExpression,
   normalizeRunJSValue,
@@ -177,7 +178,6 @@ var import_randomId = require("./randomId");
   resolveStepDisabledInSettings,
   resolveStepUiSchema,
   resolveUiMode,
-  runjsWithSafeGlobals,
   serializeCtxDateValue,
   setAutoFlowError,
   setupRuntimeContextSteps,

package/lib/utils/openViewRouteState.d.ts

@@ -0,0 +1,28 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+declare const OPEN_VIEW_ROUTE_MODES: readonly ["drawer", "dialog", "embed"];
+declare const OPEN_VIEW_ROUTE_SIZES: readonly ["small", "medium", "large"];
+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 declare const RUNJS_OPEN_VIEW_ROUTE_STATE: unique symbol;
+export declare function createOpenViewRouteState(input?: {
+    mode?: unknown;
+    size?: unknown;
+}): OpenViewRouteState | undefined;
+export declare function isOpenViewRouteStateToken(value: unknown): value is string;
+export declare function encodeOpenViewRouteState(viewUid: string, input?: {
+    mode?: unknown;
+    size?: unknown;
+}): string;
+export declare function decodeOpenViewRouteState(viewUid: string, token: unknown): OpenViewRouteState;
+export {};

package/lib/utils/openViewRouteState.js

@@ -0,0 +1,125 @@
+/**
+ * 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 openViewRouteState_exports = {};
+__export(openViewRouteState_exports, {
+  RUNJS_OPEN_VIEW_ROUTE_STATE: () => RUNJS_OPEN_VIEW_ROUTE_STATE,
+  createOpenViewRouteState: () => createOpenViewRouteState,
+  decodeOpenViewRouteState: () => decodeOpenViewRouteState,
+  encodeOpenViewRouteState: () => encodeOpenViewRouteState,
+  isOpenViewRouteStateToken: () => isOpenViewRouteStateToken
+});
+module.exports = __toCommonJS(openViewRouteState_exports);
+const OPEN_VIEW_ROUTE_MODES = ["drawer", "dialog", "embed"];
+const OPEN_VIEW_ROUTE_SIZES = ["small", "medium", "large"];
+const OPEN_VIEW_ROUTE_STATE_TOKEN_ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const OPEN_VIEW_ROUTE_STATE_TOKEN_LENGTH = 8;
+const RUNJS_OPEN_VIEW_ROUTE_STATE = Symbol.for("nocobase.runjs.openViewRouteState");
+function isOpenViewRouteMode(value) {
+  return typeof value === "string" && OPEN_VIEW_ROUTE_MODES.includes(value);
+}
+__name(isOpenViewRouteMode, "isOpenViewRouteMode");
+function isOpenViewRouteSize(value) {
+  return typeof value === "string" && OPEN_VIEW_ROUTE_SIZES.includes(value);
+}
+__name(isOpenViewRouteSize, "isOpenViewRouteSize");
+function createOpenViewRouteState(input) {
+  const state = {};
+  if (isOpenViewRouteMode(input == null ? void 0 : input.mode)) {
+    state.mode = input.mode;
+  }
+  if (isOpenViewRouteSize(input == null ? void 0 : input.size)) {
+    state.size = input.size;
+  }
+  return state.mode || state.size ? state : void 0;
+}
+__name(createOpenViewRouteState, "createOpenViewRouteState");
+function hashString(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+__name(hashString, "hashString");
+function stateToCode(state) {
+  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 : void 0;
+}
+__name(stateToCode, "stateToCode");
+function codeToState(code) {
+  const modeIndex = Math.floor(code / 4);
+  const sizeIndex = code % 4;
+  return createOpenViewRouteState({
+    mode: modeIndex ? OPEN_VIEW_ROUTE_MODES[modeIndex - 1] : void 0,
+    size: sizeIndex ? OPEN_VIEW_ROUTE_SIZES[sizeIndex - 1] : void 0
+  });
+}
+__name(codeToState, "codeToState");
+function tokenForCode(viewUid, code) {
+  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;
+}
+__name(tokenForCode, "tokenForCode");
+function isOpenViewRouteStateToken(value) {
+  return typeof value === "string" && value.length === OPEN_VIEW_ROUTE_STATE_TOKEN_LENGTH && [...value].every((char) => OPEN_VIEW_ROUTE_STATE_TOKEN_ALPHABET.includes(char));
+}
+__name(isOpenViewRouteStateToken, "isOpenViewRouteStateToken");
+function encodeOpenViewRouteState(viewUid, input) {
+  const state = createOpenViewRouteState(input);
+  const code = state ? stateToCode(state) : void 0;
+  return code ? tokenForCode(viewUid, code) : void 0;
+}
+__name(encodeOpenViewRouteState, "encodeOpenViewRouteState");
+function decodeOpenViewRouteState(viewUid, token) {
+  if (!isOpenViewRouteStateToken(token)) {
+    return void 0;
+  }
+  for (let code = 1; code < 16; code++) {
+    if (tokenForCode(viewUid, code) === token) {
+      return codeToState(code);
+    }
+  }
+  return void 0;
+}
+__name(decodeOpenViewRouteState, "decodeOpenViewRouteState");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RUNJS_OPEN_VIEW_ROUTE_STATE,
+  createOpenViewRouteState,
+  decodeOpenViewRouteState,
+  encodeOpenViewRouteState,
+  isOpenViewRouteStateToken
+});

package/lib/utils/parsePathnameToViewParams.d.ts

@@ -6,6 +6,7 @@
  * 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 OpenViewRouteState } from './openViewRouteState';
 export interface ViewParam {
     /** 视图唯一标识符，一般为某个 Model 实例的 uid */
     viewUid: string;
@@ -15,6 +16,8 @@ export interface ViewParam {
     filterByTk?: string | Record<string, string | number>;
     /** source Id */
     sourceId?: string;
+    /** RunJS ctx.openView runtime display overrides decoded from URL. */
+    openViewRouteState?: OpenViewRouteState;
 }
 export interface ParsePathnameToViewParamsOptions {
     rootPrefix?: string;

package/lib/utils/parsePathnameToViewParams.js

@@ -30,6 +30,7 @@ __export(parsePathnameToViewParams_exports, {
   parsePathnameToViewParams: () => parsePathnameToViewParams
 });
 module.exports = __toCommonJS(parsePathnameToViewParams_exports);
+var import_openViewRouteState = require("./openViewRouteState");
 const normalizePathname = /* @__PURE__ */ __name((pathname) => {
   if (!pathname || pathname === "/") {
     return "/";
@@ -77,7 +78,23 @@ const parsePathnameToViewParams = /* @__PURE__ */ __name((pathname, options = {}
       } else {
         break;
       }
-    } else if (currentView && i + 1 < segments.length) {
+    } else if (currentView) {
+      if (segment === "opts") {
+        if (i + 1 < segments.length) {
+          const routeState = (0, import_openViewRouteState.decodeOpenViewRouteState)(currentView.viewUid, segments[i + 1]);
+          if (routeState) {
+            currentView.openViewRouteState = routeState;
+          }
+          i += 2;
+        } else {
+          i++;
+        }
+        continue;
+      }
+      if (i + 1 >= segments.length) {
+        i++;
+        continue;
+      }
       const rawValue = segments[i + 1];
       let decoded = rawValue;
       try {