@nocobase/app 2.3.0-alpha.1 → 3.0.0-alpha.1

package/client-settings/rsbuild.config.ts

@@ -0,0 +1,270 @@
+/**
+ * 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 path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { defineConfig } from '@rsbuild/core';
+import { pluginLess } from '@rsbuild/plugin-less';
+import { pluginNodePolyfill } from '@rsbuild/plugin-node-polyfill';
+import { pluginReact } from '@rsbuild/plugin-react';
+import { pluginSvgr } from '@rsbuild/plugin-svgr';
+import { getRsbuildBrowserAlias } from '@nocobase/devtools/rsbuildConfig';
+import { generateSettingsPluginImports } from './generatePluginImports';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const SETTINGS_DIST_DIR = 'settings';
+
+process.env.APP_PACKAGE_ROOT ||= path.resolve(__dirname, '..');
+generateSettingsPluginImports(path.resolve(__dirname, 'src/.plugins'));
+
+function ensurePublicPath(value: string | undefined, fallback = '/') {
+  let normalized = value || fallback;
+  if (!normalized.startsWith('/')) {
+    normalized = `/${normalized}`;
+  }
+  if (!normalized.endsWith('/')) {
+    normalized = `${normalized}/`;
+  }
+  return normalized.replace(/\/{2,}/g, '/');
+}
+
+function toNumber(value: string | undefined, fallback: number) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function normalizeModernClientPrefix(value: string | undefined) {
+  const normalized = String(value || 'v')
+    .trim()
+    .replace(/^\/+|\/+$/g, '');
+  return normalized || 'v';
+}
+
+function assertAvailableModernClientPrefix(value: string | undefined) {
+  if (normalizeModernClientPrefix(value) === SETTINGS_DIST_DIR) {
+    throw new Error('APP_MODERN_CLIENT_PREFIX "settings" is reserved for the standalone Settings application.');
+  }
+}
+
+function createRuntimeHeadScript(appPublicPath: string, isBuild: boolean) {
+  return [
+    `window['__nocobase_public_path__'] = window['__nocobase_public_path__'] ?? ${JSON.stringify(appPublicPath)};`,
+    `window['__nocobase_modern_client_prefix__'] = window['__nocobase_modern_client_prefix__'] ?? ${JSON.stringify(
+      normalizeModernClientPrefix(process.env.APP_MODERN_CLIENT_PREFIX),
+    )};`,
+    `window['__webpack_public_path__'] = window['__webpack_public_path__'] ?? ${JSON.stringify(
+      isBuild ? process.env.CDN_BASE_URL || '' : '',
+    )};`,
+    `window['__nocobase_api_base_url__'] = window['__nocobase_api_base_url__'] ?? ${JSON.stringify(
+      process.env.API_BASE_URL || process.env.API_BASE_PATH || '',
+    )};`,
+    `window['__nocobase_api_client_storage_prefix__'] = window['__nocobase_api_client_storage_prefix__'] ?? ${JSON.stringify(
+      process.env.API_CLIENT_STORAGE_PREFIX || '',
+    )};`,
+    `window['__nocobase_api_client_storage_type__'] = window['__nocobase_api_client_storage_type__'] ?? ${JSON.stringify(
+      process.env.API_CLIENT_STORAGE_TYPE || '',
+    )};`,
+    `window['__nocobase_api_client_share_token__'] = window['__nocobase_api_client_share_token__'] ?? ${JSON.stringify(
+      process.env.API_CLIENT_SHARE_TOKEN || 'false',
+    )};`,
+    `window['__nocobase_ws_url__'] = window['__nocobase_ws_url__'] ?? ${JSON.stringify(
+      process.env.WEBSOCKET_URL || '',
+    )};`,
+    `window['__nocobase_ws_path__'] = window['__nocobase_ws_path__'] ?? ${JSON.stringify(process.env.WS_PATH || '')};`,
+    `window['__nocobase_app_dev__'] = window['__nocobase_app_dev__'] ?? ${JSON.stringify(
+      process.env.NOCOBASE_APP_DEV === 'true',
+    )};`,
+    `window['__esm_cdn_base_url__'] = window['__esm_cdn_base_url__'] ?? ${JSON.stringify(
+      process.env.ESM_CDN_BASE_URL || 'https://esm.sh',
+    )};`,
+    `window['__esm_cdn_suffix__'] = window['__esm_cdn_suffix__'] ?? ${JSON.stringify(
+      process.env.ESM_CDN_SUFFIX || '',
+    )};`,
+  ].join('\n');
+}
+
+function createDefineValues(appPublicPath: string) {
+  return {
+    'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || 'development'),
+    'process.env.API_BASE_URL': JSON.stringify(process.env.API_BASE_URL || process.env.API_BASE_PATH || ''),
+    'import.meta.env.APP_PUBLIC_PATH': JSON.stringify(appPublicPath),
+    'import.meta.env.API_BASE_URL': JSON.stringify(process.env.API_BASE_URL || process.env.API_BASE_PATH || ''),
+    'import.meta.env.API_CLIENT_STORAGE_PREFIX': JSON.stringify(process.env.API_CLIENT_STORAGE_PREFIX || ''),
+    'import.meta.env.API_CLIENT_STORAGE_TYPE': JSON.stringify(process.env.API_CLIENT_STORAGE_TYPE || ''),
+    'import.meta.env.API_CLIENT_SHARE_TOKEN': JSON.stringify(process.env.API_CLIENT_SHARE_TOKEN || 'false'),
+    'import.meta.env.WS_URL': JSON.stringify(process.env.WEBSOCKET_URL || ''),
+    'import.meta.env.WS_PATH': JSON.stringify(process.env.WS_PATH || ''),
+  };
+}
+
+export default defineConfig(({ command }) => {
+  const isBuild = command === 'build';
+  assertAvailableModernClientPrefix(process.env.APP_MODERN_CLIENT_PREFIX);
+
+  const appPublicPath = ensurePublicPath(process.env.APP_PUBLIC_PATH, '/');
+  const settingsPublicPath = isBuild
+    ? `/${SETTINGS_DIST_DIR}/`
+    : ensurePublicPath(`${appPublicPath}${SETTINGS_DIST_DIR}/`);
+  const apiBasePath = ensurePublicPath(process.env.API_BASE_PATH, '/api/');
+  const fileBasePath = ensurePublicPath(`${appPublicPath}files/`);
+  const localStorageBasePath = ensurePublicPath(`${appPublicPath}storage/uploads/`);
+  const staticBasePath = ensurePublicPath(`${appPublicPath}static/`);
+  const wsBasePath = ensurePublicPath(process.env.WS_PATH, '/ws/');
+  const appPort = toNumber(process.env.APP_PORT, 13001);
+  const settingsPort = toNumber(process.env.APP_SETTINGS_PORT, appPort + 3);
+  const hmrClientHost = process.env.RSPACK_HMR_CLIENT_HOST;
+  const hmrClientPort = toNumber(process.env.RSPACK_HMR_CLIENT_PORT || process.env.APP_PORT, settingsPort);
+  const proxyTargetUrl = process.env.PROXY_TARGET_URL || `http://127.0.0.1:${appPort}`;
+  const workspaceAliases = getRsbuildBrowserAlias();
+
+  return {
+    plugins: [pluginReact(), pluginLess(), pluginNodePolyfill(), pluginSvgr()],
+    resolve: {
+      alias: workspaceAliases,
+    },
+    source: {
+      entry: {
+        index: path.resolve(__dirname, 'src/main.tsx'),
+      },
+      tsconfigPath: path.resolve(__dirname, 'tsconfig.json'),
+      define: createDefineValues(appPublicPath),
+    },
+    html: {
+      template: path.resolve(__dirname, 'index.html'),
+      scriptLoading: isBuild ? 'module' : 'defer',
+      tags: [
+        {
+          tag: 'link',
+          attrs: {
+            rel: 'stylesheet',
+            href: `${settingsPublicPath}global.css`,
+          },
+          publicPath: false,
+          head: true,
+          append: false,
+        },
+        {
+          tag: 'script',
+          children: createRuntimeHeadScript(appPublicPath, isBuild),
+          head: true,
+          append: false,
+        },
+        {
+          tag: 'script',
+          attrs: {
+            src: `${settingsPublicPath}browser-checker.js?v=1`,
+          },
+          publicPath: false,
+          head: true,
+          append: false,
+        },
+      ],
+    },
+    output: {
+      target: 'web',
+      distPath: {
+        root: path.resolve(__dirname, '../dist/client/settings'),
+        js: 'assets',
+        jsAsync: 'assets',
+        css: 'assets',
+        cssAsync: 'assets',
+        svg: 'assets',
+        font: 'assets',
+        image: 'assets',
+        media: 'assets',
+      },
+      filename: {
+        js: '[name]-[contenthash:8].js',
+        css: '[name]-[contenthash:8].css',
+        svg: '[name]-[contenthash:8][ext][query]',
+        font: '[name]-[contenthash:8][ext][query]',
+        image: '[name]-[contenthash:8][ext][query]',
+        media: '[name]-[contenthash:8][ext][query]',
+      },
+      assetPrefix: settingsPublicPath,
+      cleanDistPath: true,
+      sourceMap: {
+        js: isBuild ? false : 'eval-cheap-module-source-map',
+        css: false,
+      },
+    },
+    server: {
+      base: settingsPublicPath,
+      host: '0.0.0.0',
+      port: settingsPort,
+      compress: true,
+      publicDir: {
+        name: path.resolve(__dirname, '../client-v2/public'),
+      },
+      proxy: {
+        [apiBasePath]: {
+          target: proxyTargetUrl,
+          changeOrigin: true,
+          ws: true,
+          xfwd: true,
+        },
+        [localStorageBasePath]: {
+          target: proxyTargetUrl,
+          changeOrigin: true,
+        },
+        [fileBasePath]: {
+          target: proxyTargetUrl,
+          changeOrigin: true,
+        },
+        [staticBasePath]: {
+          target: proxyTargetUrl,
+          changeOrigin: true,
+        },
+        [wsBasePath]: {
+          target: proxyTargetUrl,
+          changeOrigin: true,
+          ws: true,
+          xfwd: true,
+        },
+      },
+      historyApiFallback: {
+        disableDotRule: true,
+        index: `${settingsPublicPath}index.html`,
+      },
+    },
+    dev: {
+      assetPrefix: settingsPublicPath,
+      lazyCompilation: false,
+      client: {
+        overlay: false,
+        protocol: 'ws',
+        host: hmrClientHost,
+        port: hmrClientPort,
+        path: `${settingsPublicPath.replace(/\/$/, '')}/__rspack_hmr`,
+      },
+      progressBar: true,
+    },
+    tools: {
+      rspack(config) {
+        config.target = ['web', 'es2020'];
+        config.output.module = isBuild;
+        config.output.chunkFormat = isBuild ? 'module' : 'array-push';
+        config.experiments = {
+          ...config.experiments,
+          outputModule: isBuild,
+        };
+        config.optimization = {
+          ...config.optimization,
+          runtimeChunk: 'single',
+          splitChunks: {
+            chunks: 'all',
+          },
+        };
+        config.performance = false;
+        config.stats = 'errors-warnings';
+      },
+    },
+  };
+});

package/client-settings/src/.plugins/index.ts

@@ -0,0 +1,4 @@
+
+export default function devDynamicImport(packageName: string): Promise<any> {
+  return Promise.resolve(null);
+}

package/client-settings/src/SettingsPresetPlugin.ts

@@ -0,0 +1,56 @@
+/**
+ * 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 { Plugin, type PluginClass } from '@nocobase/client-v2';
+import { CollectionPluginV2 } from '../../../../presets/nocobase/src/client-v2/CollectionPluginV2';
+import { SettingsApplication } from '../../../client-v2/src/settings-app/SettingsApplication';
+import { SettingsBuildInPlugin } from '../../../client-v2/src/settings-app/SettingsBuildInPlugin';
+import { resolveSettingsRuntimeScope } from './runtimeScope';
+
+const CollectionPluginClass = CollectionPluginV2 as unknown as PluginClass;
+const SettingsBuildInPluginClass = SettingsBuildInPlugin as unknown as PluginClass;
+
+function offsetToTimeZone(offset: number) {
+  const hours = Math.floor(Math.abs(offset));
+  const minutes = Math.abs((offset % 1) * 60);
+  const formattedHours = String(hours).padStart(2, '0');
+  const formattedMinutes = String(minutes).padStart(2, '0');
+  const sign = offset >= 0 ? '+' : '-';
+  return `${sign}${formattedHours}:${formattedMinutes}`;
+}
+
+function getCurrentTimezone() {
+  return offsetToTimeZone(new Date().getTimezoneOffset() / -60);
+}
+
+export class SettingsPresetPlugin extends Plugin<object, SettingsApplication> {
+  private getHostname() {
+    if (process.env.API_BASE_URL) {
+      try {
+        return new URL(process.env.API_BASE_URL).hostname;
+      } catch {
+        // Fall back to the document hostname when API_BASE_URL is relative or invalid.
+      }
+    }
+    return window.location.hostname;
+  }
+
+  async afterAdd() {
+    const { basename } = resolveSettingsRuntimeScope(this.app.getPublicPath(), window.location.pathname);
+    this.router.setType('browser');
+    this.router.setBasename(basename);
+    this.app.apiClient.axios.interceptors.request.use((config) => {
+      config.headers['X-Hostname'] = this.getHostname();
+      config.headers['X-Timezone'] = getCurrentTimezone();
+      return config;
+    });
+    await this.app.pm.add(CollectionPluginClass, { name: 'builtin-collection-v2' });
+    await this.app.pm.add(SettingsBuildInPluginClass, { name: 'builtin-settings-v2' });
+  }
+}

package/client-settings/src/__tests__/runtimePublicPath.test.ts

@@ -0,0 +1,23 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { resolveSettingsAssetPublicPath } from '../runtimePublicPath';
+
+describe('Settings runtime asset public path', () => {
+  it('uses the Settings asset path without a CDN', () => {
+    expect(resolveSettingsAssetPublicPath(undefined, '/nocobase/')).toBe('/nocobase/settings/');
+  });
+
+  it('keeps Settings assets isolated under a CDN', () => {
+    expect(resolveSettingsAssetPublicPath('https://cdn.example.com/releases/42/', '/nocobase/')).toBe(
+      'https://cdn.example.com/releases/42/settings/',
+    );
+  });
+});

package/client-settings/src/__tests__/runtimeScope.test.ts

@@ -0,0 +1,29 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { resolveSettingsRuntimeScope } from '../runtimeScope';
+
+describe('Settings runtime scope', () => {
+  it('keeps the main application on the configured public path', () => {
+    expect(resolveSettingsRuntimeScope('/nocobase/', '/nocobase/settings/system-settings')).toEqual({
+      appName: undefined,
+      basename: '/nocobase/',
+      rootPublicPath: '/nocobase/',
+    });
+  });
+
+  it.each(['apps', '_app'])('derives %s application scope from the document path', (scope) => {
+    expect(resolveSettingsRuntimeScope('/nocobase/', `/nocobase/settings/${scope}/demo/workflow`)).toEqual({
+      appName: 'demo',
+      basename: `/nocobase/settings/${scope}/demo/`,
+      rootPublicPath: '/nocobase/',
+    });
+  });
+});

package/client-settings/src/env.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+
+interface ImportMetaEnv {
+  readonly APP_PUBLIC_PATH?: string;
+  readonly API_BASE_URL?: string;
+  readonly API_CLIENT_SHARE_TOKEN?: string;
+  readonly API_CLIENT_STORAGE_PREFIX?: string;
+  readonly API_CLIENT_STORAGE_TYPE?: string;
+  readonly WS_URL?: string;
+  readonly WS_PATH?: string;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}

package/client-settings/src/main.tsx

@@ -0,0 +1,78 @@
+/**
+ * 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 devDynamicImport from './.plugins';
+import type { PluginClass } from '@nocobase/client-v2';
+import { SettingsApplication } from '../../../client-v2/src/settings-app/SettingsApplication';
+import { SettingsPresetPlugin } from './SettingsPresetPlugin';
+import { resolveSettingsAssetPublicPath } from './runtimePublicPath';
+import { resolveSettingsRuntimeScope } from './runtimeScope';
+
+declare global {
+  interface Window {
+    __nocobase_public_path__?: string;
+    __webpack_public_path__?: string;
+    __nocobase_api_base_url__?: string;
+    __nocobase_api_client_storage_prefix__?: string;
+    __nocobase_api_client_storage_type__?: string;
+    __nocobase_api_client_share_token__?: boolean | string;
+    __nocobase_ws_url__?: string;
+    __nocobase_ws_path__?: string;
+  }
+}
+
+function parseShareToken(value: boolean | string | undefined) {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  return String(value || '').toLowerCase() === 'true';
+}
+
+type ClientStorageType = 'localStorage' | 'sessionStorage' | 'memory';
+
+function parseStorageType(value: string | undefined): ClientStorageType {
+  if (value === 'sessionStorage' || value === 'memory' || value === 'localStorage') {
+    return value;
+  }
+  return 'localStorage';
+}
+
+const configuredPublicPath = window.__nocobase_public_path__ || import.meta.env.APP_PUBLIC_PATH || '/';
+const runtimeScope = resolveSettingsRuntimeScope(configuredPublicPath, window.location.pathname);
+const SettingsPresetPluginClass = SettingsPresetPlugin as unknown as PluginClass;
+
+declare let __webpack_public_path__: string;
+// eslint-disable-next-line prefer-const
+__webpack_public_path__ = resolveSettingsAssetPublicPath(window.__webpack_public_path__, runtimeScope.rootPublicPath);
+
+const app = new SettingsApplication({
+  name: runtimeScope.appName,
+  publicPath: runtimeScope.rootPublicPath,
+  router: {
+    basename: runtimeScope.basename,
+  },
+  apiClient: {
+    shareToken: parseShareToken(window.__nocobase_api_client_share_token__ || import.meta.env.API_CLIENT_SHARE_TOKEN),
+    storageType: parseStorageType(
+      window.__nocobase_api_client_storage_type__ || import.meta.env.API_CLIENT_STORAGE_TYPE,
+    ),
+    storagePrefix:
+      window.__nocobase_api_client_storage_prefix__ || import.meta.env.API_CLIENT_STORAGE_PREFIX || 'NOCOBASE_',
+    baseURL: window.__nocobase_api_base_url__ || import.meta.env.API_BASE_URL || `${runtimeScope.rootPublicPath}api/`,
+  },
+  ws: {
+    url: window.__nocobase_ws_url__ || import.meta.env.WS_URL || '',
+    basename: window.__nocobase_ws_path__ || import.meta.env.WS_PATH || `${runtimeScope.rootPublicPath}ws`,
+  },
+  loadRemotePlugins: true,
+  devDynamicImport,
+  plugins: [SettingsPresetPluginClass],
+});
+
+app.mount('#root');

package/client-settings/src/runtimePublicPath.ts

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ */
+
+function normalizeBasePath(value: string | undefined, fallback: string) {
+  const normalized = String(value || fallback)
+    .trim()
+    .replace(/\/+$/, '');
+  return normalized || fallback.replace(/\/+$/, '');
+}
+
+export function resolveSettingsAssetPublicPath(cdnBaseUrl: string | undefined, appPublicPath: string) {
+  const basePath = cdnBaseUrl?.trim() ? normalizeBasePath(cdnBaseUrl, '/') : normalizeBasePath(appPublicPath, '/');
+
+  return `${basePath}/settings/`.replace(/^\/\//, '/');
+}

package/client-settings/src/runtimeScope.ts

@@ -0,0 +1,49 @@
+/**
+ * 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 {
+  resolveSettingsDocumentBasename,
+  type SettingsAppScope,
+} from '../../../client-v2/src/settings-app/settingsDocumentPath';
+
+function ensurePublicPath(value: string) {
+  let normalized = value.trim() || '/';
+  if (!normalized.startsWith('/')) {
+    normalized = `/${normalized}`;
+  }
+  if (!normalized.endsWith('/')) {
+    normalized = `${normalized}/`;
+  }
+  return normalized.replace(/\/{2,}/g, '/');
+}
+
+export function resolveSettingsRuntimeScope(configuredPublicPath: string, pathname: string) {
+  const rootPublicPath = ensurePublicPath(configuredPublicPath);
+  const normalizedPathname = pathname.startsWith('/') ? pathname : `/${pathname}`;
+  const relativePathname = normalizedPathname.startsWith(rootPublicPath)
+    ? normalizedPathname.slice(rootPublicPath.length)
+    : normalizedPathname.replace(/^\/+/, '');
+  const match = /^settings\/(apps|_app)\/([^/]+)(?:\/|$)/.exec(relativePathname);
+
+  if (!match) {
+    return {
+      appName: undefined,
+      basename: rootPublicPath,
+      rootPublicPath,
+    };
+  }
+
+  const [, scope, appName] = match;
+  const appScope = `/${scope}/${appName}` as SettingsAppScope;
+  return {
+    appName,
+    basename: resolveSettingsDocumentBasename(rootPublicPath, appScope),
+    rootPublicPath,
+  };
+}

package/client-settings/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../../../tsconfig.json",
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "importHelpers": true,
+    "jsx": "react-jsx",
+    "esModuleInterop": true,
+    "sourceMap": true,
+    "baseUrl": "../../../../",
+    "strict": true,
+    "allowSyntheticDefaultImports": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/client-v2/public/browser-checker.js

@@ -17,11 +17,86 @@ function normalizePublicPath(value) {
   return ensureTrailingSlash(normalized);
 }
 
+function normalizePathname(value) {
+  const normalized = ensureLeadingSlash(String(value || '/').trim() || '/').replace(/\/{2,}/g, '/');
+  return normalized === '/' ? normalized : normalized.replace(/\/+$/g, '');
+}
+
+function resolveSettingsRootPath(publicPath, modernPrefix, pathname) {
+  const normalizedPublicPath = normalizePublicPath(publicPath);
+  const normalizedModernPrefix =
+    String(modernPrefix || 'v')
+      .trim()
+      .replace(/^\/+|\/+$/g, '') || 'v';
+  const modernPublicPathSuffix = `/${normalizedModernPrefix}/`;
+  if (!normalizedPublicPath.endsWith(modernPublicPathSuffix)) {
+    return null;
+  }
+
+  const modernRootPath = normalizePathname(normalizedPublicPath);
+  const normalizedPathname = normalizePathname(pathname);
+  let relativePath = '';
+  if (normalizedPathname !== modernRootPath) {
+    if (!normalizedPathname.startsWith(`${modernRootPath}/`)) {
+      return null;
+    }
+    relativePath = normalizedPathname.slice(modernRootPath.length + 1);
+  }
+
+  let appScope = '';
+  if (relativePath) {
+    const match = /^(apps|_app)\/([^/]+)$/.exec(relativePath);
+    if (!match) {
+      return null;
+    }
+    appScope = `/${match[1]}/${match[2]}`;
+  }
+
+  const rootPublicPath = normalizedPublicPath.slice(0, -(normalizedModernPrefix.length + 1));
+  const rootPrefix = rootPublicPath === '/' ? '' : rootPublicPath.replace(/\/+$/g, '');
+  return `${rootPrefix}/settings${appScope}`;
+}
+
+function isSettingsBrowserCheckerScript(script) {
+  const source = String((script && script.src) || '').split(/[?#]/)[0];
+  return source.endsWith('/settings/browser-checker.js');
+}
+
+function resolveScopedSettingsRootPath(publicPath, pathname) {
+  const normalizedPublicPath = normalizePublicPath(publicPath);
+  const rootPrefix = normalizedPublicPath === '/' ? '' : normalizedPublicPath.replace(/\/+$/g, '');
+  const settingsRootPath = `${rootPrefix}/settings`;
+  if (!pathname.startsWith(`${settingsRootPath}/`)) {
+    return null;
+  }
+
+  const relativePath = pathname.slice(settingsRootPath.length + 1);
+  if (!/^(apps|_app)\/[^/]+$/.test(relativePath)) {
+    return null;
+  }
+
+  return `${pathname}/`;
+}
+
 const basename = normalizePublicPath(window['__nocobase_public_path__'] || '/');
 const currentPath = ensureLeadingSlash(String(window.location.pathname || '/').trim() || '/').replace(/\/{2,}/g, '/');
 const basenameWithoutTrailingSlash = basename === '/' ? '/' : basename.replace(/\/+$/, '');
+const appClientEntryMode = window['__nocobase_app_client_entry_mode__'];
+const settingsRootPath =
+  appClientEntryMode === 'modern-only'
+    ? resolveSettingsRootPath(basename, window['__nocobase_modern_client_prefix__'], currentPath)
+    : null;
+const scopedSettingsRootPath = isSettingsBrowserCheckerScript(document.currentScript)
+  ? resolveScopedSettingsRootPath(basename, currentPath)
+  : null;
 
-if (basename !== '/' && currentPath === basenameWithoutTrailingSlash) {
+if (settingsRootPath) {
+  const newUrl = `${window.location.origin}${settingsRootPath}${window.location.search}${window.location.hash}`;
+  window.location.replace(newUrl);
+} else if (scopedSettingsRootPath) {
+  const newUrl = `${window.location.origin}${scopedSettingsRootPath}${window.location.search}${window.location.hash}`;
+  window.location.replace(newUrl);
+} else if (basename !== '/' && currentPath === basenameWithoutTrailingSlash) {
   const newUrl = `${window.location.origin}${basename}${window.location.search}${window.location.hash}`;
   window.location.replace(newUrl);
 } else if (basename !== '/' && !currentPath.startsWith(basename)) {