@nocobase/flow-engine 2.2.0-beta.1 → 2.2.0-beta.10

package/lib/utils/dataSourceDirty.js

@@ -0,0 +1,139 @@
+/**
+ * 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 dataSourceDirty_exports = {};
+__export(dataSourceDirty_exports, {
+  getAffectedResourceNames: () => getAffectedResourceNames,
+  getDataSourceKeyFromHeaders: () => getDataSourceKeyFromHeaders,
+  getHeaderValue: () => getHeaderValue,
+  markDataSourceDirty: () => markDataSourceDirty
+});
+module.exports = __toCommonJS(dataSourceDirty_exports);
+var import_viewEvents = require("../views/viewEvents");
+function getHeaderValue(headers, name) {
+  if (!headers || typeof headers !== "object") {
+    return void 0;
+  }
+  const maybeHeaders = headers;
+  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)) {
+    if (key.toLowerCase() === lowerName) {
+      return value;
+    }
+  }
+  return void 0;
+}
+__name(getHeaderValue, "getHeaderValue");
+function getDataSourceKeyFromHeaders(headers) {
+  const value = getHeaderValue(headers, "x-data-source");
+  if (Array.isArray(value)) {
+    return String(value[0] || "main");
+  }
+  return value == null || value === "" ? "main" : String(value);
+}
+__name(getDataSourceKeyFromHeaders, "getDataSourceKeyFromHeaders");
+function getAffectedResourceNames(resourceName) {
+  const name = String(resourceName || "").trim();
+  if (!name) {
+    return [];
+  }
+  const names = /* @__PURE__ */ new Set([name]);
+  if (name.includes(".")) {
+    names.add(name.split(".")[0]);
+  }
+  return Array.from(names);
+}
+__name(getAffectedResourceNames, "getAffectedResourceNames");
+function getDirtyTargetEngines(engine, includePreviousEngines) {
+  if (!includePreviousEngines) {
+    return [engine];
+  }
+  const engines = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = engine;
+  let guard = 0;
+  while (current && guard++ < 50) {
+    if (!seen.has(current)) {
+      engines.push(current);
+      seen.add(current);
+    }
+    current = current.previousEngine;
+  }
+  return engines;
+}
+__name(getDirtyTargetEngines, "getDirtyTargetEngines");
+function markDataSourceDirty(options) {
+  var _a, _b, _c, _d;
+  const { engine, resourceName, includePreviousEngines } = options;
+  if (!(engine == null ? void 0 : engine.markDataSourceDirty)) {
+    return [];
+  }
+  const resourceNames = getAffectedResourceNames(resourceName);
+  if (!resourceNames.length) {
+    return [];
+  }
+  const dataSourceKey = String(options.dataSourceKey || "main");
+  const targetEngines = getDirtyTargetEngines(engine, includePreviousEngines);
+  const beforeVersions = /* @__PURE__ */ new Map();
+  for (const targetEngine of targetEngines) {
+    const versions = /* @__PURE__ */ new Map();
+    beforeVersions.set(targetEngine, versions);
+    for (const name of resourceNames) {
+      versions.set(name, ((_a = targetEngine.getDataSourceDirtyVersion) == null ? void 0 : _a.call(targetEngine, dataSourceKey, name)) || 0);
+    }
+  }
+  for (const targetEngine of targetEngines) {
+    const versions = beforeVersions.get(targetEngine);
+    for (const name of resourceNames) {
+      const before = (versions == null ? void 0 : versions.get(name)) || 0;
+      const current = ((_b = targetEngine.getDataSourceDirtyVersion) == null ? void 0 : _b.call(targetEngine, dataSourceKey, name)) || 0;
+      if (current !== before) {
+        continue;
+      }
+      targetEngine.markDataSourceDirty(dataSourceKey, name);
+    }
+  }
+  (_d = (_c = engine.emitter) == null ? void 0 : _c.emit) == null ? void 0 : _d.call(_c, import_viewEvents.DATA_SOURCE_DIRTY_EVENT, {
+    dataSourceKey,
+    resourceNames
+  });
+  return resourceNames;
+}
+__name(markDataSourceDirty, "markDataSourceDirty");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAffectedResourceNames,
+  getDataSourceKeyFromHeaders,
+  getHeaderValue,
+  markDataSourceDirty
+});

package/lib/utils/dirtyAwareApiClient.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 { FlowContext } from '../flowContext';
+export declare const SKIP_DATA_SOURCE_DIRTY = "__nocobaseSkipDataSourceDirty";
+export declare function getDirtyAwareApiClient(value: unknown, context: FlowContext): unknown;

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/loadedPageCache.d.ts

@@ -17,6 +17,7 @@ type DirtyKeyOptions = {
 export declare const createLoadedPageCache: () => {
     getDirtyKeyForModel(model?: FlowModel | null, options?: DirtyKeyOptions): string | undefined;
     markDirty(key?: string): void;
+    markDirtyForOptions(options?: LoadedPageOptions): void;
     shouldBypass(options?: LoadedPageOptions, isFlowSettingsEnabled?: () => boolean): boolean;
     clear(options?: LoadedPageOptions): void;
     mountModelToParent: <T extends FlowModel<import("..").DefaultStructure> = FlowModel<import("..").DefaultStructure>>(model: T, forceReplace?: boolean) => T;

package/lib/utils/loadedPageCache.js

@@ -113,6 +113,12 @@ const createLoadedPageCache = /* @__PURE__ */ __name(() => {
         dirtyKeys.add(key);
       }
     },
+    markDirtyForOptions(options) {
+      const key = getLoadedPageKey(options);
+      if (key) {
+        dirtyKeys.add(key);
+      }
+    },
     shouldBypass(options, isFlowSettingsEnabled) {
       const key = getLoadedPageKey(options);
       if (!key || !dirtyKeys.has(key)) {

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 {};