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

package/src/flow/models/blocks/form/__tests__/QuickEditFormModel.quickEdit.test.ts

@@ -7,17 +7,365 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { FlowEngine, SingleRecordResource } from '@nocobase/flow-engine';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { FlowEngine, FlowModel, SingleRecordResource } from '@nocobase/flow-engine';
 import { QuickEditFormModel } from '../QuickEditFormModel';
 
 describe('QuickEditFormModel - quick edit save triggers API (regression)', () => {
   let engine: FlowEngine;
+  const originalMatchMediaDescriptor = Object.getOwnPropertyDescriptor(window, 'matchMedia');
 
   beforeEach(() => {
     engine = new FlowEngine();
   });
 
+  afterEach(() => {
+    if (originalMatchMediaDescriptor) {
+      Object.defineProperty(window, 'matchMedia', originalMatchMediaDescriptor);
+      return;
+    }
+    delete (window as unknown as { matchMedia?: Window['matchMedia'] }).matchMedia;
+  });
+
+  const mockMatchMedia = (matches: boolean) => {
+    const matchMediaMock = vi.fn((query: string) => {
+      return {
+        matches,
+        media: query,
+        onchange: null,
+        addListener: vi.fn(),
+        removeListener: vi.fn(),
+        addEventListener: vi.fn(),
+        removeEventListener: vi.fn(),
+        dispatchEvent: vi.fn(),
+      } as unknown as MediaQueryList;
+    });
+
+    Object.defineProperty(window, 'matchMedia', {
+      ...(originalMatchMediaDescriptor || { configurable: true, writable: true }),
+      value: matchMediaMock,
+    });
+  };
+
+  const addUsersCollection = () => {
+    const ds = engine.context.dataSourceManager.getDataSource('main');
+    ds.addCollection({
+      name: 'users',
+      fields: [{ name: 'name', type: 'string', interface: 'input', uiSchema: { title: 'Name' } }],
+    });
+  };
+
+  it('uses source field context when opening quick edit', async () => {
+    engine.registerModels({ QuickEditFormModel });
+    engine.context.defineProperty('pageActive', { value: { value: false } });
+    engine.context.defineProperty('viewer', { value: { open: vi.fn(async () => undefined) } });
+
+    const page = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'page' });
+    page.context.defineProperty('pageActive', { value: { value: true } });
+    const source = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'source-field', parentId: page.uid });
+
+    await QuickEditFormModel.open({
+      flowEngine: engine,
+      target: document.createElement('div'),
+      dataSourceKey: 'main',
+      collectionName: 'users',
+      fieldPath: 'name',
+      record: {},
+      sourceFieldModelUid: source.uid,
+    });
+
+    let quickEditModel: QuickEditFormModel | undefined;
+    engine.forEachModel((model) => {
+      if (model instanceof QuickEditFormModel) {
+        quickEditModel = model;
+      }
+    });
+
+    expect(quickEditModel?.context.pageActive.value).toBe(true);
+  });
+
+  it('opens quick edit in a mobile drawer when the source field layout is mobile', async () => {
+    engine.registerModels({ QuickEditFormModel });
+    addUsersCollection();
+    const engineOpen = vi.fn(async () => undefined);
+    const sourceOpen = vi.fn(async () => undefined);
+    engine.context.defineProperty('isMobileLayout', { value: false });
+    engine.context.defineProperty('viewer', { value: { open: engineOpen } });
+    const source = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'source-field' });
+    source.context.defineProperty('isMobileLayout', { value: true });
+    source.context.defineProperty('viewer', { value: { open: sourceOpen } });
+
+    await QuickEditFormModel.open({
+      flowEngine: engine,
+      target: document.createElement('div'),
+      dataSourceKey: 'main',
+      collectionName: 'users',
+      fieldPath: 'name',
+      record: {},
+      sourceFieldModelUid: source.uid,
+    });
+
+    expect(engineOpen).not.toHaveBeenCalled();
+    expect(sourceOpen).toHaveBeenCalledTimes(1);
+    expect(sourceOpen).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'drawer',
+        title: 'Name',
+        closable: true,
+        placement: 'bottom',
+        styles: {
+          body: expect.objectContaining({
+            maxHeight: '50vh',
+          }),
+        },
+        inputArgs: {
+          isMobileLayout: true,
+        },
+      }),
+    );
+    let quickEditModel: QuickEditFormModel | undefined;
+    engine.forEachModel((model) => {
+      if (model instanceof QuickEditFormModel) {
+        quickEditModel = model;
+      }
+    });
+    expect(quickEditModel?.context.isMobileLayout).toBe(true);
+  });
+
+  it('uses the source table column title for the mobile drawer header', async () => {
+    engine.registerModels({ QuickEditFormModel });
+    addUsersCollection();
+    const sourceOpen = vi.fn(async () => undefined);
+    engine.context.defineProperty('viewer', { value: { open: vi.fn(async () => undefined) } });
+    const column = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'table-column' });
+    column.setProps({ title: 'Custom marital status' });
+    const source = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'source-field', parentId: column.uid });
+    source.context.defineProperty('isMobileLayout', { value: true });
+    source.context.defineProperty('viewer', { value: { open: sourceOpen } });
+
+    await QuickEditFormModel.open({
+      flowEngine: engine,
+      target: document.createElement('div'),
+      dataSourceKey: 'main',
+      collectionName: 'users',
+      fieldPath: 'name',
+      record: {},
+      sourceFieldModelUid: source.uid,
+    });
+
+    expect(sourceOpen).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'drawer',
+        title: 'Custom marital status',
+      }),
+    );
+  });
+
+  it('uses the mobile drawer fallback on narrow viewports', async () => {
+    engine.registerModels({ QuickEditFormModel });
+    addUsersCollection();
+    mockMatchMedia(true);
+    const viewContext = {
+      defineProperty: vi.fn(),
+    };
+    const open = vi.fn(
+      async (config: { content: (view: { close: () => void }, context: typeof viewContext) => unknown }) => {
+        config.content({ close: vi.fn() }, viewContext);
+      },
+    );
+    engine.context.defineProperty('viewer', { value: { open } });
+
+    await QuickEditFormModel.open({
+      flowEngine: engine,
+      target: document.createElement('div'),
+      dataSourceKey: 'main',
+      collectionName: 'users',
+      fieldPath: 'name',
+      record: {},
+    });
+
+    expect(open).toHaveBeenCalledTimes(1);
+    expect(viewContext.defineProperty).toHaveBeenCalledWith('isMobileLayout', { value: true });
+    expect(window.matchMedia).toHaveBeenCalledWith('(max-width: 768px)');
+    expect(open).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'drawer',
+        title: 'Name',
+        closable: true,
+        placement: 'bottom',
+        styles: {
+          body: expect.objectContaining({
+            maxHeight: '50vh',
+          }),
+        },
+        inputArgs: {
+          isMobileLayout: true,
+        },
+      }),
+    );
+    let quickEditModel: QuickEditFormModel | undefined;
+    engine.forEachModel((model) => {
+      if (model instanceof QuickEditFormModel) {
+        quickEditModel = model;
+      }
+    });
+    expect(quickEditModel?.context.isMobileLayout).toBe(true);
+  });
+
+  it('uses the engine mobile layout context without relying on matchMedia', async () => {
+    engine.registerModels({ QuickEditFormModel });
+    addUsersCollection();
+    mockMatchMedia(false);
+    const open = vi.fn(async () => undefined);
+    engine.context.defineProperty('isMobileLayout', { value: true });
+    engine.context.defineProperty('viewer', { value: { open } });
+
+    await QuickEditFormModel.open({
+      flowEngine: engine,
+      target: document.createElement('div'),
+      dataSourceKey: 'main',
+      collectionName: 'users',
+      fieldPath: 'name',
+      record: {},
+    });
+
+    expect(window.matchMedia).not.toHaveBeenCalled();
+    expect(open).toHaveBeenCalledTimes(1);
+    expect(open).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'drawer',
+        title: 'Name',
+        placement: 'bottom',
+      }),
+    );
+  });
+
+  it('keeps an explicit non-mobile layout context ahead of the narrow viewport fallback', async () => {
+    engine.registerModels({ QuickEditFormModel });
+    addUsersCollection();
+    mockMatchMedia(true);
+    const open = vi.fn(async () => undefined);
+    const target = document.createElement('div');
+    engine.context.defineProperty('isMobileLayout', { value: false });
+    engine.context.defineProperty('viewer', { value: { open } });
+
+    await QuickEditFormModel.open({
+      flowEngine: engine,
+      target,
+      dataSourceKey: 'main',
+      collectionName: 'users',
+      fieldPath: 'name',
+      record: {},
+    });
+
+    expect(window.matchMedia).not.toHaveBeenCalled();
+    expect(open).toHaveBeenCalledTimes(1);
+    expect(open).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'popover',
+        target,
+        placement: 'rightTop',
+      }),
+    );
+  });
+
+  it('keeps dynamic preventClose effective for mobile quick edit drawer containers', async () => {
+    engine.registerModels({ QuickEditFormModel });
+    addUsersCollection();
+    mockMatchMedia(true);
+    const originalBeforeClose = vi.fn(async () => true);
+    const drawerView = {
+      close: vi.fn(),
+      update: vi.fn(),
+      beforeClose: originalBeforeClose,
+    };
+    const open = vi.fn(async (config: { content: (view: typeof drawerView) => unknown }) => {
+      config.content(drawerView);
+    });
+    engine.context.defineProperty('viewer', { value: { open } });
+
+    await QuickEditFormModel.open({
+      flowEngine: engine,
+      target: document.createElement('div'),
+      dataSourceKey: 'main',
+      collectionName: 'users',
+      fieldPath: 'name',
+      record: {},
+    });
+
+    let quickEditModel: QuickEditFormModel | undefined;
+    engine.forEachModel((model) => {
+      if (model instanceof QuickEditFormModel) {
+        quickEditModel = model;
+      }
+    });
+
+    quickEditModel?.viewContainer.update?.({ preventClose: true });
+    expect(drawerView.update).toHaveBeenCalledWith({ preventClose: true });
+    await expect(drawerView.beforeClose?.({ force: false })).resolves.toBe(false);
+    expect(originalBeforeClose).not.toHaveBeenCalled();
+
+    quickEditModel?.viewContainer.update?.({ preventClose: false });
+    expect(drawerView.update).toHaveBeenCalledWith({ preventClose: false });
+    await expect(drawerView.beforeClose?.({ force: false })).resolves.toBe(true);
+    expect(originalBeforeClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('keeps desktop quick edit in the existing right-top popover', async () => {
+    engine.registerModels({ QuickEditFormModel });
+    mockMatchMedia(false);
+    const open = vi.fn(async () => undefined);
+    const target = document.createElement('div');
+    engine.context.defineProperty('viewer', { value: { open } });
+
+    await QuickEditFormModel.open({
+      flowEngine: engine,
+      target,
+      dataSourceKey: 'main',
+      collectionName: 'users',
+      fieldPath: 'name',
+      record: {},
+    });
+
+    expect(open).toHaveBeenCalledTimes(1);
+    expect(open).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'popover',
+        target,
+        placement: 'rightTop',
+        styles: {
+          body: expect.objectContaining({
+            width: 420,
+          }),
+        },
+      }),
+    );
+  });
+
+  it('keeps mobile quick edit content naturally sized with half-window scroll bounds', () => {
+    engine.registerModels({ QuickEditFormModel });
+    const model = engine.createModel<QuickEditFormModel>({
+      use: QuickEditFormModel,
+      uid: 'quick-edit-style',
+    });
+    model.context.defineProperty('isMobileLayout', { value: true });
+
+    const result = QuickEditFormModel.prototype.render.call(model) as any;
+    const formBody = result.props.children[0];
+    const actions = result.props.children[1];
+
+    expect(formBody.props.style).toMatchObject({
+      maxHeight: 'calc(50vh - var(--nb-mobile-page-header-height, 40px) - 132px)',
+      overflowY: 'auto',
+      padding: '8px var(--nb-mobile-page-tabs-content-padding, 12px) 0',
+    });
+    expect(formBody.props.style.minHeight).toBe(0);
+    expect(actions.props.style).toMatchObject({
+      justifyContent: 'flex-end',
+      padding: '8px var(--nb-mobile-page-tabs-content-padding, 12px) calc(80px + env(safe-area-inset-bottom, 0px))',
+    });
+  });
+
   it('calls update with filterByTk and merges primary key from ctx.collection/record', async () => {
     // 1) 准备数据源与集合（含主键字段）
     const dsm = engine.context.dataSourceManager;

package/src/flow/models/blocks/table/TableActionsColumnModel.tsx

@@ -121,10 +121,11 @@ const Columns = observer<any>(({ record, model, index }) => {
           fork.context.defineProperty('recordIndex', {
             get: () => index,
           });
+          const rendererKey = `${fork.uid}:${fork.forkId}`;
           const renderer = (
             <FlowModelRenderer
               showFlowSettings={{ showBorder: false, toolbarPosition: 'above' }}
-              key={fork.uid}
+              key={rendererKey}
               model={fork}
               inputArgs={record}
               fallback={<Skeleton.Button size="small" />}

package/src/flow/models/blocks/table/TableBlockModel.tsx

@@ -310,7 +310,7 @@ export class TableBlockModel extends CollectionBlockModel<TableBlockModelStructu
                 transform: translateY(-50%);
               }
               &:hover {
-                background: rgba(24, 144, 255, 0.1) !important;
+                box-shadow: inset 0 0 0 9999px rgba(24, 144, 255, 0.1);
               }
               &:hover .edit-icon {
                 display: inline-flex;

package/src/flow/models/fields/AssociationFieldModel/PopupSubTableFieldModel/PopupSubTableFieldModel.tsx

@@ -102,7 +102,7 @@ const RenderCell = observer<any>((props) => {
               transform: translateY(-50%);
             }
             &:hover {
-              background: rgba(24, 144, 255, 0.1) !important;
+              box-shadow: inset 0 0 0 9999px rgba(24, 144, 255, 0.1);
             }
             &:hover .edit-icon {
               display: inline-flex;
@@ -126,6 +126,7 @@ const RenderCell = observer<any>((props) => {
                 fieldPath: dataIndex,
                 record: record,
                 fieldProps: { ...columnModel.props, ...columnModel.subModels.field.props },
+                sourceFieldModelUid: columnModel.subModels.field.uid,
                 onOk: (values) => {
                   record[dataIndex] = values[dataIndex];
                   // 仅重渲染单元格

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

@@ -48,12 +48,12 @@ export class VariableFieldFormModel extends FlowModel {
       <FormProvider form={this.form}>
         <FormLayout layout={'vertical'}>
           {this.mapSubModels('fields', (field) => {
-            // 确保字段模型具备稳定的 id/name，便于依赖路径的组件（如公式字段）正确解析
+            // Avoid conflicting with the DOM nodeName property when rendering the temporary input.
             const init = field?.getStepParams?.('fieldSettings', 'init') || {};
             const fp = init?.fieldPath as string | undefined;
             if (fp) {
-              const namePath = fp.includes('.') ? fp.split('.') : [fp];
-              const toSet: any = {};
+              const namePath = (fp === 'nodeName' ? '__nb_variable_field_nodeName' : fp).split('.');
+              const toSet: Record<string, unknown> = {};
               if (!field?.props?.id) toSet.id = namePath;
               if (!field?.props?.name) toSet.name = namePath;
               if (Object.keys(toSet).length) field?.setProps?.(toSet);

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-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

@@ -30,6 +30,8 @@ export * from './layout-manager';
 export * from './hooks';
 export { default as languageCodes } from './locale/languageCodes';
 export * 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 +42,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,

package/src/locale/languageCodes.ts

@@ -73,7 +73,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/index.tsx

@@ -240,6 +240,16 @@ const CurrentUserProvider: FC = ({ children }) => {
           return;
         }
 
+        try {
+          await app.apiClient.auth.syncCookies();
+        } catch {
+          // Cookie bootstrap is best-effort; auth:check remains the source of truth for the current page load.
+        }
+
+        if (!mounted) {
+          return;
+        }
+
         const userMeta = createCollectionContextMeta(
           () => app.flowEngine.context.dataSourceManager?.getDataSource('main')?.getCollection('users') || null,
           app.flowEngine.translate('Current user'),
@@ -298,6 +308,8 @@ const CurrentUserProvider: FC = ({ children }) => {
   return <CurrentUserContext.Provider value={contextValue}>{children}</CurrentUserContext.Provider>;
 };
 
+CurrentUserProvider.displayName = 'CurrentUserProvider';
+
 const RootRedirect: FC = () => {
   const app = useApp<Application>();
   const hasToken = !!app?.apiClient?.auth?.token;