@nocobase/flow-engine 2.1.0-beta.9 → 2.2.0-beta.1

package/lib/utils/loadedPageCache.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 loadedPageCache_exports = {};
+__export(loadedPageCache_exports, {
+  createLoadedPageCache: () => createLoadedPageCache
+});
+module.exports = __toCommonJS(loadedPageCache_exports);
+const getLoadedPageKey = /* @__PURE__ */ __name((options) => {
+  const parentId = options == null ? void 0 : options.parentId;
+  const subKey = options == null ? void 0 : options.subKey;
+  if (!parentId || subKey !== "page") {
+    return void 0;
+  }
+  return `${parentId}::${subKey}`;
+}, "getLoadedPageKey");
+const getLoadedPageKeyFromModel = /* @__PURE__ */ __name((model) => {
+  var _a;
+  let current = model;
+  while (current) {
+    if (current.subKey === "page" && ((_a = current.parent) == null ? void 0 : _a.uid)) {
+      return getLoadedPageKey({ parentId: current.parent.uid, subKey: current.subKey });
+    }
+    current = current.parent;
+  }
+  return void 0;
+}, "getLoadedPageKeyFromModel");
+const isFlowSettingsEnabledForContext = /* @__PURE__ */ __name((context) => {
+  try {
+    return !!(context == null ? void 0 : context.flowSettingsEnabled);
+  } catch (error) {
+    return false;
+  }
+}, "isFlowSettingsEnabledForContext");
+const isFlowSettingsEnabledForModel = /* @__PURE__ */ __name((model) => {
+  if (isFlowSettingsEnabledForContext(model == null ? void 0 : model.context)) {
+    return true;
+  }
+  const visited = /* @__PURE__ */ new Set();
+  let engine = model == null ? void 0 : model.flowEngine;
+  while (engine && !visited.has(engine)) {
+    visited.add(engine);
+    if (isFlowSettingsEnabledForContext(engine.context)) {
+      return true;
+    }
+    engine = engine.previousEngine;
+  }
+  return false;
+}, "isFlowSettingsEnabledForModel");
+const removeLoadedModelTree = /* @__PURE__ */ __name((model) => {
+  if (!(model == null ? void 0 : model.uid) || !model.flowEngine) {
+    return;
+  }
+  if (model.flowEngine.getModel(model.uid) === model) {
+    model.flowEngine.removeModelWithSubModels(model.uid);
+  }
+}, "removeLoadedModelTree");
+const mountLoadedModelToParent = /* @__PURE__ */ __name((model, forceReplace = false) => {
+  var _a;
+  if (!(model == null ? void 0 : model.parent) || !model.subKey) {
+    return model;
+  }
+  const mounted = (_a = model.parent.subModels) == null ? void 0 : _a[model.subKey];
+  const existing = forceReplace && model.subType !== "array" && mounted && !Array.isArray(mounted) ? mounted : model.parent.findSubModel(model.subKey, (m) => m.uid === model.uid);
+  if (existing) {
+    if (!forceReplace || existing === model) {
+      return model;
+    }
+    removeLoadedModelTree(existing);
+  }
+  if (model.subType === "array") {
+    model.parent.addSubModel(model.subKey, model);
+  } else {
+    model.parent.setSubModel(model.subKey, model);
+  }
+  return model;
+}, "mountLoadedModelToParent");
+const createLoadedPageCache = /* @__PURE__ */ __name(() => {
+  const dirtyKeys = /* @__PURE__ */ new Set();
+  return {
+    getDirtyKeyForModel(model, options) {
+      if (!(options == null ? void 0 : options.force) && !isFlowSettingsEnabledForModel(model)) {
+        return void 0;
+      }
+      return getLoadedPageKeyFromModel(model);
+    },
+    markDirty(key) {
+      if (key) {
+        dirtyKeys.add(key);
+      }
+    },
+    shouldBypass(options, isFlowSettingsEnabled) {
+      const key = getLoadedPageKey(options);
+      if (!key || !dirtyKeys.has(key)) {
+        return false;
+      }
+      try {
+        return !(isFlowSettingsEnabled == null ? void 0 : isFlowSettingsEnabled());
+      } catch (error) {
+        return true;
+      }
+    },
+    clear(options) {
+      const key = getLoadedPageKey(options);
+      if (key) {
+        dirtyKeys.delete(key);
+      }
+    },
+    mountModelToParent: mountLoadedModelToParent
+  };
+}, "createLoadedPageCache");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLoadedPageCache
+});

package/lib/utils/parsePathnameToViewParams.d.ts

@@ -16,6 +16,10 @@ export interface ViewParam {
     /** source Id */
     sourceId?: string;
 }
+export interface ParsePathnameToViewParamsOptions {
+    rootPrefix?: string;
+    basePath?: string;
+}
 /**
  * 解析路径名为视图参数数组
  *
@@ -31,4 +35,4 @@ export interface ViewParam {
  * parsePathnameToViewParams('/admin/xxx/view/yyy') // [{ viewUid: 'xxx' }, { viewUid: 'yyy' }]
  * ```
  */
-export declare const parsePathnameToViewParams: (pathname: string) => ViewParam[];
+export declare const parsePathnameToViewParams: (pathname: string, options?: ParsePathnameToViewParamsOptions) => ViewParam[];

package/lib/utils/parsePathnameToViewParams.js

@@ -30,20 +30,44 @@ __export(parsePathnameToViewParams_exports, {
   parsePathnameToViewParams: () => parsePathnameToViewParams
 });
 module.exports = __toCommonJS(parsePathnameToViewParams_exports);
-const parsePathnameToViewParams = /* @__PURE__ */ __name((pathname) => {
+const normalizePathname = /* @__PURE__ */ __name((pathname) => {
+  if (!pathname || pathname === "/") {
+    return "/";
+  }
+  return `/${pathname.replace(/^\/+/, "").replace(/\/+$/, "")}`;
+}, "normalizePathname");
+const normalizeBasePath = /* @__PURE__ */ __name((basePath) => `/${basePath.replace(/^\/+/, "").replace(/\/+$/, "")}`, "normalizeBasePath");
+const stripBasePath = /* @__PURE__ */ __name((pathname, basePath) => {
+  const normalizedPathname = normalizePathname(pathname);
+  const normalizedBasePath = normalizeBasePath(basePath);
+  if (normalizedPathname === normalizedBasePath) {
+    return "";
+  }
+  if (normalizedPathname.startsWith(`${normalizedBasePath}/`)) {
+    return normalizedPathname.slice(normalizedBasePath.length + 1);
+  }
+  return "";
+}, "stripBasePath");
+const parsePathnameToViewParams = /* @__PURE__ */ __name((pathname, options = {}) => {
   if (!pathname || pathname === "/") {
     return [];
   }
-  const segments = pathname.replace(/^\/+/, "").split("/").filter(Boolean);
-  if (segments.length < 2) {
+  const rootPrefix = options.rootPrefix || "admin";
+  const relativePath = options.basePath ? stripBasePath(pathname, options.basePath) : "";
+  const segments = (options.basePath ? relativePath : pathname).replace(/^\/+/, "").split("/").filter(Boolean);
+  if (segments.length < (options.basePath ? 1 : 2)) {
     return [];
   }
   const result = [];
   let currentView = null;
   let i = 0;
+  if (options.basePath) {
+    currentView = { viewUid: segments[0] };
+    i = 1;
+  }
   while (i < segments.length) {
     const segment = segments[i];
-    if (segment === "admin" || segment === "view") {
+    if (segment === rootPrefix || segment === "view") {
       if (currentView) {
         result.push(currentView);
       }

package/lib/utils/randomId.d.ts

@@ -0,0 +1,39 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+/**
+ * Generate a random base36 identifier with an optional semantic prefix.
+ *
+ * Equivalent in shape to v1's `uid()` from `@formily/shared` (11 chars
+ * of `[0-9a-z]`), with an opt-in prefix appended at the front. v2 forbids
+ * direct `@formily/*` imports in `src/client-v2/`, so this helper is the
+ * single substitute the rest of the codebase should reach for.
+ *
+ * Common semantic prefixes observed across the codebase — pass the one
+ * that matches your domain rather than relying on a default, so the
+ * intent is explicit at the call site:
+ *
+ *   - `s_` — service / settings record (authenticators, channels, …)
+ *   - `v_` — verifier / variable / LLM service
+ *   - `f_` — field
+ *   - `t_` — through table
+ *
+ * Example:
+ *
+ * ```ts
+ * import { randomId } from '@nocobase/flow-engine';
+ *
+ * name: randomId('s_'),  // → 's_keeoaui1ubi'
+ * name: randomId('v_'),  // → 'v_a8f3kp2x9qm'
+ * name: randomId(),      // → 'a8f3kp2x9qm'
+ * ```
+ *
+ * Not cryptographically secure — uses `Math.random()`. Good enough for
+ * unique form names / schema keys, NOT for security tokens.
+ */
+export declare function randomId(prefix?: string, length?: number): string;

package/lib/utils/randomId.js

@@ -0,0 +1,45 @@
+/**
+ * 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 randomId_exports = {};
+__export(randomId_exports, {
+  randomId: () => randomId
+});
+module.exports = __toCommonJS(randomId_exports);
+const CHARSET = "0123456789abcdefghijklmnopqrstuvwxyz";
+function randomId(prefix = "", length = 11) {
+  let id = "";
+  for (let i = 0; i < length; i++) {
+    id += CHARSET[Math.random() * CHARSET.length | 0];
+  }
+  return `${prefix}${id}`;
+}
+__name(randomId, "randomId");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randomId
+});

package/lib/utils/runjsTemplateCompat.js

@@ -527,8 +527,8 @@ function extractUsedCtxLibKeys(code) {
 }
 __name(extractUsedCtxLibKeys, "extractUsedCtxLibKeys");
 function injectEnsureLibsPreamble(code) {
-  if (!CTX_LIBS_MARKER_RE.test(code)) return code;
   if (ENSURE_LIBS_MARKER_RE.test(code)) return code;
+  if (!CTX_LIBS_MARKER_RE.test(code)) return code;
   const keys = extractUsedCtxLibKeys(code);
   if (!keys.length) return code;
   return `/* __runjs_ensure_libs */

package/lib/utils/runjsValue.js

@@ -231,6 +231,34 @@ function normalizeSubPath(raw) {
   return { subPath: s, wildcard: false };
 }
 __name(normalizeSubPath, "normalizeSubPath");
+function extractCtxRootUsage(expr) {
+  const raw = String(expr || "").trim();
+  if (!raw || raw === "ctx") return null;
+  const dotMatch = raw.match(/^ctx\.([a-zA-Z_$][a-zA-Z0-9_$]*)([\s\S]*)$/);
+  if (dotMatch) {
+    const varName = dotMatch[1] || "";
+    const rest = dotMatch[2] || "";
+    const normalized = normalizeSubPath(rest);
+    return {
+      varName,
+      subPath: normalized.subPath,
+      wildcard: normalized.wildcard
+    };
+  }
+  const bracketMatch = raw.match(/^ctx\s*\[\s*(['"])([a-zA-Z_$][a-zA-Z0-9_$]*)\1\s*\]([\s\S]*)$/);
+  if (bracketMatch) {
+    const varName = bracketMatch[2] || "";
+    const rest = bracketMatch[3] || "";
+    const normalized = normalizeSubPath(rest);
+    return {
+      varName,
+      subPath: normalized.subPath,
+      wildcard: normalized.wildcard
+    };
+  }
+  return null;
+}
+__name(extractCtxRootUsage, "extractCtxRootUsage");
 function extractUsedVariablePathsFromRunJS(code) {
   if (typeof code !== "string" || !code.trim()) return {};
   const src = stripStringsAndComments(code);
@@ -242,23 +270,25 @@ function extractUsedVariablePathsFromRunJS(code) {
     set.add(subPath || "");
     usage.set(varName, set);
   }, "add");
+  const addCtxUsage = /* @__PURE__ */ __name((expr) => {
+    const hit = extractCtxRootUsage(expr);
+    if (!(hit == null ? void 0 : hit.varName)) return;
+    add(hit.varName, hit.wildcard ? "" : hit.subPath);
+  }, "addCtxUsage");
   const dotRe = /ctx\.([a-zA-Z_$][a-zA-Z0-9_$]*(?:(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*)|(?:\[[^\]]+\]))*)(?!\s*\()/g;
   let match;
   while (match = dotRe.exec(src)) {
-    const pathAfterCtx = match[1] || "";
-    const firstKeyMatch = pathAfterCtx.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)/);
-    if (!firstKeyMatch) continue;
-    const firstKey = firstKeyMatch[1];
-    const rest = pathAfterCtx.slice(firstKey.length);
-    const { subPath, wildcard } = normalizeSubPath(rest);
-    add(firstKey, wildcard ? "" : subPath);
+    addCtxUsage(`ctx.${match[1] || ""}`);
   }
   const bracketRootRe = /ctx\s*\[\s*(['"])([a-zA-Z_$][a-zA-Z0-9_$]*)\1\s*\]((?:(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*)|(?:\[[^\]]+\]))*)(?!\s*\()/g;
   while (match = bracketRootRe.exec(srcWithStrings)) {
-    const varName = match[2] || "";
-    const rest = match[3] || "";
-    const { subPath, wildcard } = normalizeSubPath(rest);
-    add(varName, wildcard ? "" : subPath);
+    addCtxUsage(`ctx['${match[2] || ""}']${match[3] || ""}`);
+  }
+  const getVarRe = /ctx\.getVar\s*\(\s*(['"])((?:\\.|(?!\1)[\s\S])*)\1\s*\)/g;
+  while (match = getVarRe.exec(srcWithStrings)) {
+    const expr = String(match[2] || "").replace(/\\'/g, "'").replace(/\\"/g, '"').trim();
+    if (!expr.startsWith("ctx")) continue;
+    addCtxUsage(expr);
   }
   const out = {};
   for (const [k, set] of usage.entries()) {

package/lib/utils/schema-utils.d.ts

@@ -9,7 +9,7 @@
 import type { ISchema } from '@formily/json-schema';
 import type { FlowModel } from '../models';
 import { FlowRuntimeContext } from '../flowContext';
-import type { StepDefinition, StepUIMode } from '../types';
+import type { EventDefinition, StepDefinition, StepUIMode } from '../types';
 /**
  * 解析 uiMode，支持静态值和函数形式
  * 函数可以接收 FlowRuntimeContext
@@ -38,6 +38,12 @@ export declare function compileUiSchema(scope: Record<string, any>, uiSchema: an
  * @returns 合并后的uiSchema对象，如果为空则返回null
  */
 export declare function resolveStepUiSchema<TModel extends FlowModel = FlowModel>(model: TModel, flow: any, step: StepDefinition): Promise<Record<string, ISchema> | null>;
+/**
+ * 判断事件在设置菜单中是否应被隐藏。
+ * - 支持 EventDefinition.hideInSettings。
+ * - hideInSettings 可为布尔值或函数（接收 FlowRuntimeContext）。
+ */
+export declare function shouldHideEventInSettings<TModel extends FlowModel = FlowModel>(model: TModel, flow: any, event: EventDefinition<TModel> | undefined): Promise<boolean>;
 /**
  * 判断步骤在设置菜单中是否应被隐藏。
  * - 支持 StepDefinition.hideInSettings 与 ActionDefinition.hideInSettings（step 优先）。

package/lib/utils/schema-utils.js

@@ -31,6 +31,7 @@ __export(schema_utils_exports, {
   resolveStepDisabledInSettings: () => resolveStepDisabledInSettings,
   resolveStepUiSchema: () => resolveStepUiSchema,
   resolveUiMode: () => resolveUiMode,
+  shouldHideEventInSettings: () => shouldHideEventInSettings,
   shouldHideStepInSettings: () => shouldHideStepInSettings
 });
 module.exports = __toCommonJS(schema_utils_exports);
@@ -195,6 +196,23 @@ async function resolveStepUiSchema(model, flow, step) {
   return resolvedStepUiSchema;
 }
 __name(resolveStepUiSchema, "resolveStepUiSchema");
+async function shouldHideEventInSettings(model, flow, event) {
+  if (!event) return true;
+  const { hideInSettings } = event;
+  if (typeof hideInSettings === "function") {
+    try {
+      const ctx = new import_flowContext.FlowRuntimeContext(model, flow.key, "settings");
+      (0, import_setupRuntimeContextSteps.setupRuntimeContextSteps)(ctx, flow.steps || {}, model, flow.key);
+      const result = await hideInSettings(ctx);
+      return !!result;
+    } catch (error) {
+      console.warn(`Error evaluating hideInSettings for event '${event.name || ""}' in flow '${flow.key}':`, error);
+      return false;
+    }
+  }
+  return !!hideInSettings;
+}
+__name(shouldHideEventInSettings, "shouldHideEventInSettings");
 async function shouldHideStepInSettings(model, flow, step) {
   var _a;
   if (!step) return true;
@@ -283,5 +301,6 @@ __name(resolveStepDisabledInSettings, "resolveStepDisabledInSettings");
   resolveStepDisabledInSettings,
   resolveStepUiSchema,
   resolveUiMode,
+  shouldHideEventInSettings,
   shouldHideStepInSettings
 });

package/lib/views/FlowView.d.ts

@@ -10,6 +10,11 @@
 import { PopoverProps as AntdPopoverProps } from 'antd';
 import { FlowContext } from '../flowContext';
 import { ViewNavigation } from './ViewNavigation';
+export type FlowViewBeforeClosePayload = {
+    result?: any;
+    force?: boolean;
+};
+export type FlowViewBeforeCloseHandler = (payload: FlowViewBeforeClosePayload) => Promise<boolean | void> | boolean | void;
 export type FlowView = {
     type: 'drawer' | 'popover' | 'dialog' | 'embed';
     inputArgs: any;
@@ -20,8 +25,9 @@ export type FlowView = {
     Footer: React.FC<{
         children?: React.ReactNode;
     }> | null;
-    close: (result?: any, force?: boolean) => void;
+    close: (result?: any, force?: boolean) => Promise<boolean | void> | boolean | void;
     update: (newConfig: any) => void;
+    beforeClose?: FlowViewBeforeCloseHandler;
     navigation?: ViewNavigation;
     /** 页面的销毁方法 */
     destroy?: () => void;

package/lib/views/FlowView.js

@@ -47,11 +47,21 @@ const _FlowViewer = class _FlowViewer {
     if (this.types[type]) {
       zIndex += 1;
       const onClose = others.onClose;
+      let zIndexReleased = false;
+      const releaseZIndex = /* @__PURE__ */ __name(() => {
+        if (!zIndexReleased) {
+          zIndexReleased = true;
+          zIndex -= 1;
+        }
+      }, "releaseZIndex");
       const _zIndex = others.zIndex;
       others.onClose = (...args) => {
         onClose == null ? void 0 : onClose(...args);
-        zIndex -= 1;
+        releaseZIndex();
       };
+      if (type === "embed") {
+        others.onOpenCancelled = releaseZIndex;
+      }
       if (type !== "embed") {
         others.zIndex = _zIndex ?? this.getNextZIndex();
       }

package/lib/views/PageComponent.js

@@ -55,8 +55,9 @@ const PageComponent = (0, import_react.forwardRef)((props, ref) => {
     hidden,
     title: _title,
     styles = {},
-    zIndex = 4
+    zIndex = 4,
     // 这个默认值是为了防止表格的阴影显示到子页面上面
+    onClose
   } = mergedProps;
   const closedRef = (0, import_react.useRef)(false);
   const flowEngine = (0, import_provider.useFlowEngine)();
@@ -114,11 +115,12 @@ const PageComponent = (0, import_react.forwardRef)((props, ref) => {
           type: "text",
           size: "small",
           icon: /* @__PURE__ */ import_react.default.createElement(import_icons.CloseOutlined, null),
-          onClick: () => {
-            var _a;
+          onClick: async () => {
             if (!closedRef.current) {
-              closedRef.current = true;
-              (_a = props.onClose) == null ? void 0 : _a.call(props);
+              const closed = await (onClose == null ? void 0 : onClose());
+              if (closed !== false) {
+                closedRef.current = true;
+              }
             }
           },
           style: {
@@ -138,7 +140,7 @@ const PageComponent = (0, import_react.forwardRef)((props, ref) => {
       )),
       extra && /* @__PURE__ */ import_react.default.createElement("div", null, extra)
     );
-  }, [header, _title, flowEngine.context.themeToken, styles.header, props.onClose]);
+  }, [header, _title, flowEngine.context.themeToken, styles.header, onClose]);
   const FooterComponent = (0, import_react.useMemo)(() => {
     if (!footer) return null;
     const token = flowEngine.context.themeToken;

package/lib/views/ViewNavigation.d.ts

@@ -11,6 +11,14 @@ import { ViewParam as SharedViewParam } from '../utils';
 type ViewParams = Omit<SharedViewParam, 'viewUid'> & {
     viewUid?: string;
 };
+export interface GeneratePathnameFromViewParamsOptions {
+    prefix?: string;
+    basePath?: string;
+}
+export interface ViewNavigationOptions {
+    basePath?: string;
+    layoutBasePath?: string;
+}
 /**
  * 将 ViewParam 数组转换为 pathname
  *
@@ -24,12 +32,13 @@ type ViewParams = Omit<SharedViewParam, 'viewUid'> & {
  * generatePathnameFromViewParams([{ viewUid: 'xxx' }, { viewUid: 'yyy' }]) // '/admin/xxx/view/yyy'
  * ```
  */
-export declare function generatePathnameFromViewParams(viewParams: ViewParams[]): string;
+export declare function generatePathnameFromViewParams(viewParams: ViewParams[], options?: GeneratePathnameFromViewParamsOptions): string;
 export declare class ViewNavigation {
     viewStack: ReadonlyArray<ViewParams>;
     ctx: FlowEngineContext;
     viewParams: ViewParams;
-    constructor(ctx: FlowEngineContext, viewParams: ViewParams[]);
+    private readonly basePath?;
+    constructor(ctx: FlowEngineContext, viewParams: ViewParams[], options?: ViewNavigationOptions);
     setViewStack(viewParams: ViewParams[]): void;
     changeTo(viewParam: ViewParams): void;
     navigateTo(viewParam: ViewParams, opts?: {
@@ -37,5 +46,6 @@ export declare class ViewNavigation {
         state?: any;
     }): void;
     back(): void;
+    private getLayoutBasePath;
 }
 export {};

package/lib/views/ViewNavigation.js

@@ -43,11 +43,21 @@ function encodeFilterByTk(val) {
   return encodeURIComponent(String(val));
 }
 __name(encodeFilterByTk, "encodeFilterByTk");
-function generatePathnameFromViewParams(viewParams) {
+function hasUsableSourceId(sourceId) {
+  return sourceId !== void 0 && sourceId !== null && String(sourceId) !== "";
+}
+__name(hasUsableSourceId, "hasUsableSourceId");
+function normalizeBasePath(basePath) {
+  const value = basePath || "/admin";
+  return `/${value.replace(/^\/+/, "").replace(/\/+$/, "")}`;
+}
+__name(normalizeBasePath, "normalizeBasePath");
+function generatePathnameFromViewParams(viewParams, options = {}) {
+  const basePath = normalizeBasePath(options.basePath || options.prefix);
   if (!viewParams || viewParams.length === 0) {
-    return "/admin";
+    return basePath;
   }
-  const segments = ["admin"];
+  const segments = basePath.replace(/^\/+/, "").split("/").filter(Boolean);
   viewParams.forEach((viewParam, index) => {
     if (index > 0) {
       segments.push("view");
@@ -62,8 +72,8 @@ function generatePathnameFromViewParams(viewParams) {
         segments.push("filterbytk", encoded);
       }
     }
-    if (viewParam.sourceId) {
-      segments.push("sourceid", viewParam.sourceId);
+    if (hasUsableSourceId(viewParam.sourceId)) {
+      segments.push("sourceid", String(viewParam.sourceId));
     }
   });
   return "/" + segments.join("/");
@@ -74,9 +84,11 @@ const _ViewNavigation = class _ViewNavigation {
   // 只能通过 setViewStack 修改
   ctx;
   viewParams;
-  constructor(ctx, viewParams) {
+  basePath;
+  constructor(ctx, viewParams, options = {}) {
     this.setViewStack(viewParams);
     this.ctx = ctx;
+    this.basePath = options.basePath || options.layoutBasePath;
     (0, import_reactive.define)(this, {
       viewParams: import_reactive.observable
     });
@@ -92,19 +104,26 @@ const _ViewNavigation = class _ViewNavigation {
       }
       return { ...item };
     });
-    const newPathname = generatePathnameFromViewParams(newViewStack);
+    const newPathname = generatePathnameFromViewParams(newViewStack, { basePath: this.getLayoutBasePath() });
     this.ctx.router.navigate(newPathname, { replace: true });
   }
   navigateTo(viewParam, opts) {
-    const newViewPathname = generatePathnameFromViewParams([...this.viewStack, viewParam]);
+    const newViewPathname = generatePathnameFromViewParams([...this.viewStack, viewParam], {
+      basePath: this.getLayoutBasePath()
+    });
     const newPathname = newViewPathname;
     this.ctx.router.navigate(newPathname, opts);
   }
   back() {
     const prevStack = this.viewStack.slice(0, -1);
-    const prevPath = generatePathnameFromViewParams(prevStack);
+    const prevPath = generatePathnameFromViewParams(prevStack, { basePath: this.getLayoutBasePath() });
     this.ctx.router.navigate(prevPath, { replace: true });
   }
+  getLayoutBasePath() {
+    var _a, _b;
+    const routePath = (_a = this.ctx.layout) == null ? void 0 : _a.routePath;
+    return this.basePath || ((_b = this.ctx.layoutRoute) == null ? void 0 : _b.basePathname) || ((routePath == null ? void 0 : routePath.startsWith("/")) ? routePath : "/admin");
+  }
 };
 __name(_ViewNavigation, "ViewNavigation");
 let ViewNavigation = _ViewNavigation;