@nocobase/client-v2 2.2.0-beta.9 → 3.0.0-alpha.1

package/src/flow/models/fields/__tests__/JsonFieldModel.test.ts

@@ -0,0 +1,82 @@
+/**
+ * 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 { FlowEngine, FlowModel } from '@nocobase/flow-engine';
+import { describe, expect, it } from 'vitest';
+import { JsonFieldModel } from '../JsonFieldModel';
+
+interface ValidationRule {
+  required?: boolean;
+  type?: string;
+  validator?: (_rule: unknown, value: unknown) => Promise<void>;
+}
+
+function createModels(rules: ValidationRule[]) {
+  const engine = new FlowEngine();
+  engine.registerModels({ JsonFieldModel });
+  const parent = engine.createModel<FlowModel<{ subModels: { field: JsonFieldModel } }>>({
+    use: FlowModel,
+    uid: 'json-form-item',
+    props: { rules },
+    subModels: {
+      field: {
+        use: JsonFieldModel,
+        uid: 'json-field',
+      },
+    },
+  });
+
+  return { field: parent.subModels.field, parent };
+}
+
+function initializeJsonValidation(field: JsonFieldModel) {
+  const step = field.getFlow('jsonInitSetting')?.steps.initValidation;
+  if (!step) {
+    throw new Error('JSON validation step is not registered');
+  }
+  step.handler(field.context, {});
+}
+
+describe('JsonFieldModel validation', () => {
+  it('replaces legacy empty rules with one serializable JSON validation rule', async () => {
+    const { field, parent } = createModels([{}, { required: true }]);
+
+    initializeJsonValidation(field);
+
+    const rules = parent.props.rules as ValidationRule[];
+    expect(rules).toHaveLength(2);
+    expect(rules[0]).toEqual({ required: true });
+    expect(rules[1]).toMatchObject({ type: 'any' });
+    expect(rules[1].validator).toBeTypeOf('function');
+    if (!rules[1].validator) {
+      throw new Error('JSON validator is missing');
+    }
+    await expect(rules[1].validator({}, { name: 'NocoBase' })).resolves.toBeUndefined();
+    await expect(rules[1].validator({}, '{"name":')).rejects.toContain('Invalid JSON format');
+
+    const persistedRules = JSON.parse(JSON.stringify(parent.serialize())).props.rules as ValidationRule[];
+    expect(persistedRules).toHaveLength(2);
+    expect(persistedRules[1]).toMatchObject({ type: 'any' });
+    expect(persistedRules[1].validator).toBeUndefined();
+  });
+
+  it('re-registers the runtime validator without duplicating its persisted placeholder', () => {
+    const { field, parent } = createModels([{}]);
+    initializeJsonValidation(field);
+    const persistedRules = JSON.parse(JSON.stringify(parent.serialize())).props.rules as ValidationRule[];
+    parent.setProps({ rules: persistedRules });
+
+    initializeJsonValidation(field);
+
+    const rules = parent.props.rules as ValidationRule[];
+    expect(rules).toHaveLength(1);
+    expect(rules[0]).toMatchObject({ type: 'any' });
+    expect(rules[0].validator).toBeTypeOf('function');
+  });
+});

package/src/flow/models/fields/__tests__/VariableFieldFormModel.test.tsx

@@ -0,0 +1,51 @@
+/**
+ * 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 { FlowEngine, FlowEngineProvider } from '@nocobase/flow-engine';
+import { render, screen, waitFor } from '@testing-library/react';
+import React from 'react';
+import { describe, expect, it } from 'vitest';
+import { InputFieldModel } from '../InputFieldModel';
+import { VariableFieldFormModel } from '../VariableFieldFormModel';
+
+describe('VariableFieldFormModel', () => {
+  it('uses DOM-safe name and id for temporary controls created from reserved form property names', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ InputFieldModel, VariableFieldFormModel });
+    const model = engine.createModel<VariableFieldFormModel>({
+      use: 'VariableFieldFormModel',
+      subModels: {
+        fields: [
+          {
+            use: 'InputFieldModel',
+            stepParams: {
+              fieldSettings: {
+                init: {
+                  fieldPath: 'nodeName',
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+    const field = model.subModels.fields[0];
+
+    render(<FlowEngineProvider engine={engine}>{model.render()}</FlowEngineProvider>);
+
+    const input = await screen.findByRole('textbox');
+    await waitFor(() => {
+      expect(field.props.name).toEqual(['__nb_variable_field_nodeName']);
+    });
+    expect(input).toHaveAttribute('name', '__nb_variable_field_nodeName');
+    expect(input).toHaveAttribute('id', '__nb_variable_field_nodeName');
+    expect(field.props.id).toEqual(['__nb_variable_field_nodeName']);
+    expect(field.getStepParams('fieldSettings', 'init')).toEqual({ fieldPath: 'nodeName' });
+  });
+});

package/src/flow/models/fields/mobile-components/MobileLazySelect.tsx

@@ -23,6 +23,20 @@ import {
 } from '../AssociationFieldModel/recordSelectShared';
 import _ from 'lodash';
 
+const mobileSelectSafeAreaPaddingBottom = 'calc(12px + env(safe-area-inset-bottom, 0px))';
+
+const mobileSelectConfirmFooterStyle: CSSProperties = {
+  paddingBottom: mobileSelectSafeAreaPaddingBottom,
+};
+
+function getMobileSelectListStyle(hasConfirmFooter: boolean): CSSProperties {
+  return {
+    maxHeight: '60vh',
+    overflowY: 'auto',
+    paddingBottom: hasConfirmFooter ? undefined : mobileSelectSafeAreaPaddingBottom,
+  };
+}
+
 const labelClassName = css`
   div {
     white-space: nowrap !important;
@@ -280,13 +294,7 @@ export function MobileLazySelect(props: Readonly<LazySelectProps>) {
             showCancelButton
           />
         </div>
-        <div
-          style={{
-            maxHeight: '60vh',
-            overflowY: 'auto',
-          }}
-          onScroll={handleScroll}
-        >
+        <div style={getMobileSelectListStyle(isMultiple)} onScroll={handleScroll}>
           <CheckList multiple={isMultiple} value={selectedValueIds} onChange={handleListChange}>
             {realOptions.map((item) => {
               const optionValue = item?.[valueKey];
@@ -311,9 +319,11 @@ export function MobileLazySelect(props: Readonly<LazySelectProps>) {
           )}
         </div>
         {isMultiple && (
-          <Button block color="primary" onClick={handleConfirm} style={{ marginTop: '16px' }}>
-            {t('Confirm')}
-          </Button>
+          <div style={mobileSelectConfirmFooterStyle}>
+            <Button block color="primary" onClick={handleConfirm} style={{ marginTop: '16px' }}>
+              {t('Confirm')}
+            </Button>
+          </div>
         )}
       </Popup>
     </>

package/src/flow/models/fields/mobile-components/MobileSelect.tsx

@@ -12,8 +12,23 @@ import { Select } from 'antd';
 import { Button, CheckList, Popup, SearchBar } from 'antd-mobile';
 import React, { useEffect, useMemo, useState } from 'react';
 
+const mobileSelectSafeAreaPaddingBottom = 'calc(12px + env(safe-area-inset-bottom, 0px))';
+
+const mobileSelectConfirmFooterStyle: React.CSSProperties = {
+  paddingBottom: mobileSelectSafeAreaPaddingBottom,
+};
+
+function getMobileSelectListStyle(hasConfirmFooter: boolean): React.CSSProperties {
+  return {
+    maxHeight: '60vh',
+    overflowY: 'auto',
+    paddingBottom: hasConfirmFooter ? undefined : mobileSelectSafeAreaPaddingBottom,
+  };
+}
+
 export function MobileSelect(props) {
   const { value, displayValue, onChange, onChangeComplete, disabled, options = [], mode } = props;
+  const isMultiple = ['multiple', 'tags'].includes(mode);
   const ctx = useFlowModelContext();
   const t = ctx.t;
   const [visible, setVisible] = useState(false);
@@ -64,17 +79,12 @@ export function MobileSelect(props) {
         <div style={{ margin: '10px' }}>
           <SearchBar placeholder={t('search')} value={searchText} onChange={(v) => setSearchText(v)} showCancelButton />
         </div>
-        <div
-          style={{
-            maxHeight: '60vh',
-            overflowY: 'auto',
-          }}
-        >
+        <div style={getMobileSelectListStyle(isMultiple)}>
           <CheckList
-            multiple={['multiple', 'tags'].includes(mode)}
+            multiple={isMultiple}
             value={Array.isArray(selected) ? selected : [selected]}
             onChange={(val) => {
-              if (['multiple', 'tags'].includes(mode)) {
+              if (isMultiple) {
                 setSelected(val);
               } else {
                 setSelected(val[0]);
@@ -91,10 +101,12 @@ export function MobileSelect(props) {
             ))}
           </CheckList>
         </div>
-        {['multiple', 'tags'].includes(mode) && (
-          <Button block color="primary" onClick={handleConfirm} style={{ marginTop: '16px' }}>
-            {t('Confirm')}
-          </Button>
+        {isMultiple && (
+          <div style={mobileSelectConfirmFooterStyle}>
+            <Button block color="primary" onClick={handleConfirm} style={{ marginTop: '16px' }}>
+              {t('Confirm')}
+            </Button>
+          </div>
         )}
       </Popup>
     </>

package/src/flow/models/topbar/TopbarActionModel.tsx

@@ -14,12 +14,11 @@ import { Button, Dropdown, theme, Tooltip, type ButtonProps, type MenuProps } fr
 import React, { useEffect, useMemo, useState } from 'react';
 import { useHotkeys } from 'react-hotkeys-hook';
 import { useTranslation } from 'react-i18next';
-import { Link, useLocation } from 'react-router-dom';
+import { useLocation } from 'react-router-dom';
 import { useACLRoleContext } from '../../../acl';
-import type { BaseApplication } from '../../../BaseApplication';
 import type { PluginSettingsPageType } from '../../../PluginSettingsManager';
-import { shouldOpenAdminRouteInNewWindow } from '../../../RouterManager';
 import { useApp } from '../../../hooks/useApp';
+import { resolveStandaloneSettingsPath } from '../../../settings-app/runtimePaths';
 import {
   filterRenderableSettings,
   filterVisibleSettings,
@@ -66,109 +65,6 @@ const topbarActionTriggerClassName = css`
   height: 100%;
 `;
 
-type TopbarSettingsAppLike = Pick<
-  BaseApplication<any>,
-  'name' | 'router' | 'getPublicPath' | 'getHref' | 'layoutManager'
->;
-
-const normalizeTopbarPath = (pathname?: string) => {
-  const trimmed = pathname?.trim();
-  if (!trimmed || trimmed === '/') {
-    return '/';
-  }
-  return `/${trimmed.replace(/^\/+/, '')}`;
-};
-
-const normalizeTopbarBasePath = (pathname?: string) => {
-  const normalized = normalizeTopbarPath(pathname).replace(/\/+$/, '');
-  return normalized === '' || normalized === '/' ? '' : normalized;
-};
-
-const getTopbarRouterBasePath = (app: TopbarSettingsAppLike | undefined) => {
-  return app?.router?.getBasename?.() || app?.router?.basename || app?.getPublicPath?.() || '';
-};
-
-const stripTopbarRouterBasePath = (pathname: string, basename?: string) => {
-  const normalizedPath = normalizeTopbarPath(pathname);
-  const normalizedBase = normalizeTopbarBasePath(basename);
-
-  if (!normalizedBase) {
-    return normalizedPath;
-  }
-
-  if (normalizedPath === normalizedBase) {
-    return '/';
-  }
-
-  if (normalizedPath.startsWith(`${normalizedBase}/`)) {
-    return normalizeTopbarPath(normalizedPath.slice(normalizedBase.length));
-  }
-
-  return normalizedPath;
-};
-
-const getTopbarAppPath = (pathname: string) => {
-  const normalizedPath = normalizeTopbarPath(pathname);
-  const match = /^(.*?\/(?:apps|_app)\/[^/]+)(?=\/|$)/.exec(normalizedPath);
-  const appPath = match?.[1] || '';
-
-  return {
-    appPath,
-    routePath: appPath ? normalizeTopbarPath(normalizedPath.slice(appPath.length)) : normalizedPath,
-  };
-};
-
-const getTopbarContextAppPath = (app: TopbarSettingsAppLike | undefined, basename?: string) => {
-  const basenameAppPath = getTopbarAppPath(basename || '').appPath;
-  if (basenameAppPath) {
-    return basenameAppPath;
-  }
-
-  const publicPathAppPath = getTopbarAppPath(app?.getPublicPath?.() || '').appPath;
-  if (publicPathAppPath) {
-    return publicPathAppPath;
-  }
-
-  if (app?.name && app.name !== 'main' && app.getHref) {
-    return normalizeTopbarBasePath(app.getHref('/'));
-  }
-
-  return '';
-};
-
-const prependTopbarAppPath = (pathname: string, appPath: string) => {
-  const normalizedPath = normalizeTopbarPath(pathname);
-
-  if (!appPath || normalizedPath === appPath || normalizedPath.startsWith(`${appPath}/`)) {
-    return normalizedPath;
-  }
-
-  return `${appPath}${normalizedPath}`;
-};
-
-const isAdminRuntimePath = (pathname: string) => {
-  return pathname === '/admin' || pathname.startsWith('/admin/');
-};
-
-const getTopbarAdminRoutePath = (app: TopbarSettingsAppLike | undefined) => {
-  try {
-    return app?.layoutManager?.getLayout?.('admin')?.routePath;
-  } catch {
-    return undefined;
-  }
-};
-
-const buildTopbarDocumentHref = (targetPath: string, basename?: string) => {
-  const normalizedTarget = normalizeTopbarPath(targetPath);
-  const normalizedBase = normalizeTopbarBasePath(basename);
-
-  if (!normalizedBase || normalizedTarget === normalizedBase || normalizedTarget.startsWith(`${normalizedBase}/`)) {
-    return normalizedTarget;
-  }
-
-  return `${normalizedBase}${normalizedTarget}`;
-};
-
 function TopbarExternalSettingsLabel(props: { title: React.ReactNode; link: string }) {
   return (
     <div
@@ -185,39 +81,13 @@ function TopbarInternalSettingsLabel(props: { title: React.ReactNode; path?: str
   const app = useApp();
   const location = useLocation();
   const targetPath = props.path || '/admin/settings';
-  const basename = getTopbarRouterBasePath(app);
-  const currentPath = stripTopbarRouterBasePath(location.pathname, basename);
-  const currentLocationAppPath = getTopbarAppPath(currentPath);
-  const currentAppPath = currentLocationAppPath.appPath || getTopbarContextAppPath(app, basename);
-  const currentRoutePath = currentLocationAppPath.appPath ? currentLocationAppPath.routePath : currentPath;
-  const targetPathInCurrentApp = prependTopbarAppPath(stripTopbarRouterBasePath(targetPath, basename), currentAppPath);
-
-  if (currentAppPath) {
-    const href = buildTopbarDocumentHref(targetPathInCurrentApp, basename);
-    const shouldOpenInNewWindow = shouldOpenAdminRouteInNewWindow({
-      currentPathname: currentPath,
-      targetPathname: targetPathInCurrentApp,
-      basePath: basename,
-      adminRoutePath: getTopbarAdminRoutePath(app),
-    });
-
-    return (
-      <a
-        href={href}
-        target={shouldOpenInNewWindow ? '_blank' : undefined}
-        rel={shouldOpenInNewWindow ? 'noopener noreferrer' : undefined}
-      >
-        {props.title}
-      </a>
-    );
-  }
-
-  if (isAdminRuntimePath(currentRoutePath)) {
-    return <Link to={targetPathInCurrentApp}>{props.title}</Link>;
-  }
 
   return (
-    <a href={buildTopbarDocumentHref(targetPath, basename)} target="_blank" rel="noopener noreferrer">
+    <a
+      href={resolveStandaloneSettingsPath(app, targetPath, location.pathname)}
+      target="_blank"
+      rel="noopener noreferrer"
+    >
       {props.title}
     </a>
   );
@@ -238,66 +108,68 @@ export function getTopbarPluginSettingsItems(options: {
 }): NonNullable<MenuProps['items']> {
   const { settings, canManagePlugins, t } = options;
   const topLevelSettings = filterVisibleSettings(filterRenderableSettings(settings));
-  const pluginManagerSetting = topLevelSettings.find((item) => item.name === PLUGIN_MANAGER_SETTING_NAME);
+  const primarySettings = sortTopLevelSettings(
+    topLevelSettings
+      .filter(
+        (item) =>
+          ((item.sort || 0) < 0 || item.name === PLUGIN_MANAGER_SETTING_NAME) &&
+          (item.name !== PLUGIN_MANAGER_SETTING_NAME || canManagePlugins),
+      )
+      .map((item) => ({
+        ...item,
+        children: undefined,
+      })),
+  );
   const settingsByKey = new Map<string, PluginSettingsPageType>();
   const normalSettings = sortTopLevelSettings(
     topLevelSettings
-      .filter((item) => item.name !== PLUGIN_MANAGER_SETTING_NAME)
+      .filter((item) => (item.sort || 0) >= 0 && item.name !== PLUGIN_MANAGER_SETTING_NAME)
       .map((item) => ({
         ...item,
         children: undefined,
       })),
   );
 
-  normalSettings.forEach((item) => {
+  [...primarySettings, ...normalSettings].forEach((item) => {
     settingsByKey.set(item.key, item);
   });
 
-  const orderedSettings = (getMenuItems(normalSettings) || []).map((item: any) => {
-    if (item?.type === 'divider') {
-      return item;
-    }
-
-    const matchedSetting = settingsByKey.get(String(item.key));
-    const targetPath = matchedSetting?.path;
-    const targetLink = matchedSetting?.link;
-    const targetTitle = matchedSetting?.title || item.title;
-
-    return {
-      key: item.key,
-      name: matchedSetting?.name,
-      path: matchedSetting?.path,
-      link: targetLink,
-      title: targetTitle,
-      icon: item.icon,
-      label: targetLink ? (
-        <TopbarExternalSettingsLabel title={targetTitle} link={targetLink} />
-      ) : (
-        <TopbarInternalSettingsLabel title={targetTitle} path={targetPath} />
-      ),
-    };
-  });
-
-  const items: NonNullable<MenuProps['items']> = [];
-
-  if (canManagePlugins && pluginManagerSetting) {
-    items.push({
-      key: pluginManagerSetting.key,
-      icon: pluginManagerSetting.icon || <ApiOutlined />,
-      label: (
-        <TopbarInternalSettingsLabel
-          title={pluginManagerSetting.title || t('Plugin manager')}
-          path={pluginManagerSetting.path}
-        />
-      ),
+  const buildMenuItems = (targetSettings: PluginSettingsPageType[]) =>
+    (getMenuItems(targetSettings) || []).map((item: any) => {
+      if (item?.type === 'divider') {
+        return item;
+      }
+
+      const matchedSetting = settingsByKey.get(String(item.key));
+      const targetPath = matchedSetting?.path;
+      const targetLink = matchedSetting?.link;
+      const isPluginManager = matchedSetting?.name === PLUGIN_MANAGER_SETTING_NAME;
+      const targetTitle = matchedSetting?.title || (isPluginManager ? t('Plugin manager') : item.title);
+
+      return {
+        key: item.key,
+        name: matchedSetting?.name,
+        path: matchedSetting?.path,
+        link: targetLink,
+        title: targetTitle,
+        icon: isPluginManager ? matchedSetting?.icon || <ApiOutlined /> : item.icon,
+        label: targetLink ? (
+          <TopbarExternalSettingsLabel title={targetTitle} link={targetLink} />
+        ) : (
+          <TopbarInternalSettingsLabel title={targetTitle} path={targetPath} />
+        ),
+      };
     });
-  }
 
-  if (canManagePlugins && orderedSettings.length) {
+  const primaryItems = buildMenuItems(primarySettings);
+  const normalItems = buildMenuItems(normalSettings);
+  const items: NonNullable<MenuProps['items']> = [...primaryItems];
+
+  if (primaryItems.length && normalItems.length) {
     items.push({ type: 'divider' });
   }
 
-  items.push(...orderedSettings);
+  items.push(...normalItems);
 
   return items;
 }

package/src/flow/utils/dataScopeFormValueClear.ts

@@ -105,9 +105,6 @@ function resolveItemDependencyPath(ctx: FlowContext, depPath: NamePath): DataSco
     ctx,
     parseFieldIndexEntries((ctx.model as any)?.context?.fieldIndex ?? (ctx as any)?.fieldIndex),
   );
-  if (!entries.length) {
-    return wildcardDeps();
-  }
 
   let parentDepth = 0;
   let cursor = [...depPath];
@@ -121,6 +118,10 @@ function resolveItemDependencyPath(ctx: FlowContext, depPath: NamePath): DataSco
     return wildcardDeps();
   }
 
+  if (!entries.length) {
+    return parentDepth === 0 ? resolveRootItemDependencyPath(cursor) : emptyDeps();
+  }
+
   if (parentDepth === entries.length) {
     return resolveRootItemDependencyPath(cursor);
   }

package/src/flow-compat/fieldValidationConstants.ts

@@ -231,7 +231,7 @@ export const FIELDS_VALIDATION_OPTIONS = {
     },
     {
       key: 'multiple',
-      label: 'Multiple',
+      label: 'Multiple of',
       hasValue: true,
       params: [{ key: 'base', label: 'Base', componentType: 'inputNumber', required: true }],
     },

package/src/flow-compat/routeTypes.ts

@@ -18,6 +18,7 @@ export enum NocoBaseDesktopRouteType {
 
 export interface NocoBaseDesktopRouteOptions {
   hasPersistedMenuInstanceFlow?: boolean;
+  hasPersistedPageTabFlowModel?: boolean;
   [key: string]: any;
 }
 

package/src/index.ts

@@ -29,7 +29,16 @@ export * from './PluginSettingsManager';
 export * from './layout-manager';
 export * from './hooks';
 export { default as languageCodes } from './locale/languageCodes';
-export * from './nocobase-buildin-plugin';
+export {
+  CurrentUserContext,
+  NocoBaseBuildInPlugin,
+  NocoBaseBuildInPluginV2,
+  useCurrentRoles,
+  useCurrentUserContext,
+} from './nocobase-buildin-plugin';
+export type { CurrentRoleOption, CurrentUserState } from './nocobase-buildin-plugin';
+export { getRouteRuntimeVersion } from './utils/getRouteRuntimeVersion';
+export type { RouteRuntimeVersion } from './utils/getRouteRuntimeVersion';
 export * from './collection-field-interface/CollectionFieldInterface';
 export * from './collection-field-interface/CollectionFieldInterfaceManager';
 export * from './collection-manager/field-configure';
@@ -40,6 +49,8 @@ export * from './collection-manager/template-fields';
 export * from './data-source';
 export * from './entry-actions';
 export * from './flow';
+export { CodeEditorExtension } from './flow/components/code-editor/extension';
+export type { CodeEditorExtra, CodeEditorExtraRegistry, EditorRef } from './flow/components/code-editor/types';
 export {
   DEFAULT_DATA_SOURCE_KEY,
   IconPicker,
@@ -50,3 +61,5 @@ export {
 export type { NocoBaseDesktopRoute } from './flow-compat';
 export * from './utils/markdownSanitize';
 export { default as AntdAppProvider } from './theme/AntdAppProvider';
+export { isSettingsApp } from './settings-app/isSettingsApp';
+export { MINIMAL_THEME_UID, useSettingsThemeConfig } from './settings-app/useSettingsThemeConfig';

package/src/locale/languageCodes.ts

@@ -54,6 +54,7 @@ export const languageCodes: Record<string, LocaleOptions> = {
   'ml-IN': { label: 'മലയാളം' },
   'mn-MN': { label: 'Монгол хэл' },
   'ms-MY': { label: 'بهاس ملايو' },
+  'my-MM': { label: 'မြန်မာဘာသာ' },
   'nb-NO': { label: 'Norsk bokmål' },
   'ne-NP': { label: 'नेपाली' },
   'nl-BE': { label: 'Vlaams' },
@@ -73,7 +74,8 @@ export const languageCodes: Record<string, LocaleOptions> = {
   'tk-TK': { label: 'Turkmen' },
   'tr-TR': { label: 'Türkçe' },
   'uk-UA': { label: 'Українська' },
-  'ur-PK': { label: 'Oʻzbekcha' },
+  'ur-PK': { label: 'اردو' },
+  'uz-UZ': { label: 'Oʻzbekcha' },
   'vi-VN': { label: 'Tiếng Việt' },
   'zh-CN': { label: '简体中文' },
   'zh-HK': { label: '繁體中文（香港）' },

package/src/nocobase-buildin-plugin/currentUserAuthStatus.ts

@@ -0,0 +1,58 @@
+/**
+ * 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 { useSyncExternalStore } from 'react';
+
+export type CurrentUserAuthStatus = 'unknown' | 'authenticated' | 'unauthenticated' | 'redirecting';
+
+type AuthStatusStore = {
+  getSnapshot: () => CurrentUserAuthStatus;
+  set: (status: CurrentUserAuthStatus) => void;
+  subscribe: (listener: () => void) => () => void;
+};
+
+const stores = new WeakMap<object, AuthStatusStore>();
+
+function createAuthStatusStore(): AuthStatusStore {
+  let status: CurrentUserAuthStatus = 'unknown';
+  const listeners = new Set<() => void>();
+
+  return {
+    getSnapshot: () => status,
+    set: (nextStatus) => {
+      if (status === nextStatus) {
+        return;
+      }
+      status = nextStatus;
+      listeners.forEach((listener) => listener());
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+  };
+}
+
+function getAuthStatusStore(app: object) {
+  let store = stores.get(app);
+  if (!store) {
+    store = createAuthStatusStore();
+    stores.set(app, store);
+  }
+  return store;
+}
+
+export function setCurrentUserAuthStatus(app: object, status: CurrentUserAuthStatus) {
+  getAuthStatusStore(app).set(status);
+}
+
+export function useCurrentUserAuthStatus(app: object) {
+  const store = getAuthStatusStore(app);
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+}