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

package/src/components/category-tabs/SortableCategoryTabs.tsx

@@ -0,0 +1,210 @@
+/**
+ * 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 { MenuOutlined } from '@ant-design/icons';
+import {
+  DndContext,
+  DragOverlay,
+  MouseSensor,
+  useDraggable,
+  useDroppable,
+  useSensor,
+  useSensors,
+  type DragEndEvent,
+  type DragStartEvent,
+} from '@dnd-kit/core';
+import { Badge, Button, Dropdown, Space, Tabs } from 'antd';
+import type { TabsProps } from 'antd';
+import React, { useCallback, useMemo, useState } from 'react';
+
+/**
+ * A category descriptor for {@link SortableCategoryTabs}. The component is
+ * i18n-agnostic: `label` is rendered verbatim, so consumers pass an
+ * already-compiled/translated node. `color` is an antd preset color name or a
+ * hex string; `'default'` / `undefined` renders no badge color.
+ */
+export type SortableCategoryTabItem = {
+  id: string | number;
+  label: React.ReactNode;
+  color?: string;
+};
+
+export type SortableCategoryTabsProps = {
+  activeKey: string;
+  onChange: (key: string) => void;
+  /** Draggable category tabs (the fixed leading tab is configured via `allTab`). */
+  categories: SortableCategoryTabItem[];
+  /** The fixed, non-draggable leading tab, e.g. "All". */
+  allTab: { key: string; label: React.ReactNode };
+  /** Show the "+" add button and handle its click. */
+  onAdd?: () => void;
+  /** Per-category edit menu item handler; menu is hidden when omitted. */
+  onEdit?: (id: string | number) => void;
+  /** Per-category delete menu item handler; menu is hidden when omitted. */
+  onDelete?: (id: string | number) => void;
+  /** Reorder handler. Receives the dragged and dropped category ids. */
+  onSort?: (sourceId: string | number, targetId: string | number) => void | Promise<void>;
+  /** Consumer-translated labels for the per-category dropdown menu. */
+  menuLabels?: { edit?: string; delete?: string };
+  className?: string;
+};
+
+function DraggableTab(props: { id: string; children: React.ReactNode }) {
+  const { attributes, listeners, setNodeRef } = useDraggable({ id: props.id });
+  return (
+    <div ref={setNodeRef} {...listeners} {...attributes}>
+      {props.children}
+    </div>
+  );
+}
+
+function DroppableTab(props: { id: string; children: React.ReactNode }) {
+  const { isOver, setNodeRef } = useDroppable({ id: props.id });
+  return (
+    <div ref={setNodeRef} style={isOver ? { color: 'green' } : undefined}>
+      {props.children}
+    </div>
+  );
+}
+
+function CategoryTabContent(props: {
+  item: SortableCategoryTabItem;
+  onEdit?: (id: string | number) => void;
+  onDelete?: (id: string | number) => void;
+  menuLabels?: { edit?: string; delete?: string };
+}) {
+  const { item, onEdit, onDelete, menuLabels } = props;
+  const hasMenu = Boolean(onEdit || onDelete);
+  const editLabel = menuLabels?.edit ?? 'Edit';
+  const deleteLabel = menuLabels?.delete ?? 'Delete';
+
+  return (
+    <Space size={6}>
+      <Badge color={item.color === 'default' ? undefined : item.color} />
+      {item.label}
+      {hasMenu ? (
+        <Dropdown
+          trigger={['click']}
+          menu={{
+            items: [
+              onEdit ? { key: 'edit', label: editLabel } : null,
+              onDelete ? { key: 'delete', label: deleteLabel } : null,
+            ].filter(Boolean) as { key: string; label: string }[],
+            onClick({ key, domEvent }) {
+              domEvent.stopPropagation();
+              if (key === 'edit') {
+                onEdit?.(item.id);
+                return;
+              }
+              onDelete?.(item.id);
+            },
+          }}
+        >
+          <Button
+            aria-label={editLabel}
+            icon={<MenuOutlined />}
+            size="small"
+            type="text"
+            onClick={(event) => event.stopPropagation()}
+          />
+        </Dropdown>
+      ) : null}
+    </Space>
+  );
+}
+
+/**
+ * A draggable, editable category tab bar. Renders only the tab bar (no content
+ * panes) — the page renders its content below and reacts to `activeKey`.
+ *
+ * Shared by settings pages that group records under reorderable categories
+ * (data-source collections, workflows, …). Drag-to-reorder is powered by
+ * `@dnd-kit`; the "+" / per-tab edit-delete affordances are optional.
+ */
+export function SortableCategoryTabs(props: SortableCategoryTabsProps) {
+  const { activeKey, onChange, categories, allTab, onAdd, onEdit, onDelete, onSort, menuLabels, className } = props;
+  const [activeDragId, setActiveDragId] = useState<string | null>(null);
+  const sensors = useSensors(useSensor(MouseSensor, { activationConstraint: { distance: 10 } }));
+
+  const handleDragStart = useCallback((event: DragStartEvent) => {
+    setActiveDragId(String(event.active.id));
+  }, []);
+
+  const handleDragEnd = useCallback(
+    async (event: DragEndEvent) => {
+      const { active, over } = event;
+      setActiveDragId(null);
+      if (!over || over.id === active.id) {
+        return;
+      }
+      await onSort?.(active.id as string | number, over.id as string | number);
+    },
+    [onSort],
+  );
+
+  const items = useMemo<TabsProps['items']>(
+    () => [
+      { key: allTab.key, label: allTab.label, closable: false },
+      ...categories.map((item) => ({
+        key: String(item.id),
+        closable: false,
+        label: onSort ? (
+          <DroppableTab id={String(item.id)}>
+            <DraggableTab id={String(item.id)}>
+              <CategoryTabContent item={item} onEdit={onEdit} onDelete={onDelete} menuLabels={menuLabels} />
+            </DraggableTab>
+          </DroppableTab>
+        ) : (
+          <CategoryTabContent item={item} onEdit={onEdit} onDelete={onDelete} menuLabels={menuLabels} />
+        ),
+      })),
+    ],
+    [allTab.key, allTab.label, categories, onSort, onEdit, onDelete, menuLabels],
+  );
+
+  const activeDragItem = useMemo(
+    () => categories.find((item) => String(item.id) === activeDragId),
+    [categories, activeDragId],
+  );
+
+  const tabs = (
+    <Tabs
+      className={className}
+      activeKey={activeKey}
+      type="editable-card"
+      hideAdd={!onAdd}
+      items={items}
+      onChange={onChange}
+      onEdit={(_, action) => {
+        if (action === 'add') {
+          onAdd?.();
+        }
+      }}
+    />
+  );
+
+  if (!onSort) {
+    return tabs;
+  }
+
+  return (
+    <DndContext sensors={sensors} onDragStart={handleDragStart} onDragEnd={handleDragEnd}>
+      {tabs}
+      <DragOverlay dropAnimation={null}>
+        {activeDragItem ? (
+          <span style={{ whiteSpace: 'nowrap' }}>
+            <CategoryTabContent item={activeDragItem} menuLabels={menuLabels} />
+          </span>
+        ) : null}
+      </DragOverlay>
+    </DndContext>
+  );
+}
+
+export default SortableCategoryTabs;

package/src/components/category-tabs/index.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+
+export * from './SortableCategoryTabs';

package/src/components/form/JsonTextArea.tsx

@@ -117,6 +117,10 @@ const JsonTextAreaComponent = React.forwardRef<TextAreaRef, JsonTextAreaProps>((
   return (
     <>
       <Input.TextArea
+        autoSize={{
+          minRows: 5,
+          maxRows: 10,
+        }}
         {...textAreaProps}
         ref={ref}
         value={text}

package/src/components/form/ScanInput/CodeScanner.tsx

@@ -49,6 +49,21 @@ function CodeScannerContent({ visible, formatsToSupport, onClose, onScanSuccess
     message.error(t('Code recognition failed, please scan again'));
   }, [t]);
 
+  const showCameraStartFailure = useCallback(
+    (error: unknown) => {
+      const errorName = error instanceof Error ? error.name : '';
+      const errorMessage = error instanceof Error ? error.message : '';
+      const errorMap: Record<string, string> = {
+        NotFoundError: t('No camera device detected'),
+        NotAllowedError: t('You have not granted permission to use the camera'),
+      };
+
+      message.error(errorMap[errorName] || errorMessage || t('You have not granted permission to use the camera'));
+      onClose();
+    },
+    [onClose, t],
+  );
+
   const handleScanSuccess = useCallback(
     (text: string) => {
       onScanSuccess(text);
@@ -64,6 +79,7 @@ function CodeScannerContent({ visible, formatsToSupport, onClose, onScanSuccess
     scanBoxSize,
     onScanSuccess: handleScanSuccess,
     onScanFailure: showScanFailure,
+    onCameraStartFailure: showCameraStartFailure,
   });
 
   useEffect(() => {
@@ -129,7 +145,7 @@ function CodeScannerContent({ visible, formatsToSupport, onClose, onScanSuccess
     inset: 0;
     z-index: ${token.zIndexPopupBase + 1000};
     overflow: hidden;
-    background: ${token.colorBgMask};
+    background: #000;
   `;
   const scannerWrapperClass = css`
     position: absolute;
@@ -137,16 +153,17 @@ function CodeScannerContent({ visible, formatsToSupport, onClose, onScanSuccess
     overflow: hidden;
   `;
   const scannerClass = css`
+    position: relative;
     width: 100%;
     height: 100%;
-    display: flex;
-    justify-content: center;
-    align-items: center;
+    overflow: hidden;
 
     video {
-      width: auto !important;
+      position: absolute !important;
+      inset: 0 !important;
+      width: 100% !important;
       height: 100% !important;
-      max-width: none !important;
+      object-fit: cover !important;
     }
 
     #qr-shaded-region {

package/src/components/form/ScanInput/__tests__/useCodeScanner.test.tsx

@@ -7,9 +7,9 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { render, waitFor } from '@testing-library/react';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
 import React, { useCallback } from 'react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { DEFAULT_CODE_FORMATS, getCodeScanBoxSize, useCodeScanner } from '../useCodeScanner';
 
 type MockScannerInstance = {
@@ -44,6 +44,12 @@ const mocks = vi.hoisted(() => {
   };
 });
 
+const jsQrMocks = vi.hoisted(() => {
+  return {
+    default: vi.fn(),
+  };
+});
+
 vi.mock('html5-qrcode', () => ({
   Html5Qrcode: mocks.Html5Qrcode,
   Html5QrcodeScannerState: {
@@ -66,22 +72,99 @@ vi.mock('html5-qrcode', () => ({
   },
 }));
 
-function ScannerHost({ scanBoxSize }: { scanBoxSize?: { width: number; height: number } } = {}) {
+vi.mock('jsqr', () => jsQrMocks);
+
+function ScannerHost({
+  onCameraStartFailure,
+  onScanFailure,
+  scanBoxSize,
+}: {
+  onCameraStartFailure?: (error: unknown) => void;
+  onScanFailure?: () => void;
+  scanBoxSize?: { width: number; height: number };
+} = {}) {
   const handleScanSuccess = useCallback(() => undefined, []);
 
   useCodeScanner({
     elementId: 'scanner',
     enabled: true,
     scanBoxSize,
+    onCameraStartFailure,
+    onScanFailure,
     onScanSuccess: handleScanSuccess,
   });
 
   return <div id="scanner" />;
 }
 
+function FileScannerHost({ onScanSuccess }: { onScanSuccess: (text: string) => void }) {
+  const { startScanFile } = useCodeScanner({
+    elementId: 'scanner',
+    enabled: true,
+    onScanSuccess,
+  });
+
+  return (
+    <>
+      <div id="scanner" />
+      <button onClick={() => startScanFile(new File(['qr'], 'qr.png', { type: 'image/png' }))}>scan file</button>
+    </>
+  );
+}
+
+function stubSafariBrowser() {
+  vi.spyOn(window.navigator, 'vendor', 'get').mockReturnValue('Apple Computer, Inc.');
+  vi.spyOn(window.navigator, 'userAgent', 'get').mockReturnValue(
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15',
+  );
+}
+
+function stubImageElement(size: { width: number; height: number } = { width: 600, height: 400 }) {
+  vi.stubGlobal(
+    'Image',
+    class MockImage {
+      onabort: ((event: Event) => void) | null = null;
+      onerror: ((event: Event) => void) | null = null;
+      onload: (() => void) | null = null;
+      height = size.height;
+      naturalHeight = size.height;
+      naturalWidth = size.width;
+      width = size.width;
+
+      set src(_value: string) {
+        this.onload?.();
+      }
+    },
+  );
+  vi.stubGlobal('URL', {
+    ...URL,
+    createObjectURL: vi.fn(() => 'blob:qr'),
+    revokeObjectURL: vi.fn(),
+  });
+}
+
+function stubCanvas() {
+  const canvasContext = {
+    drawImage: vi.fn(),
+    getImageData: vi.fn((_x: number, _y: number, width: number, height: number) => ({
+      data: new Uint8ClampedArray(width * height * 4),
+      height,
+      width,
+    })),
+  } as unknown as CanvasRenderingContext2D;
+
+  vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockReturnValue(canvasContext);
+}
+
 describe('useCodeScanner', () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    jsQrMocks.default.mockReturnValue(undefined);
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
   });
 
   it('starts scanning with QR code and barcode formats by default', async () => {
@@ -120,4 +203,98 @@ describe('useCodeScanner', () => {
 
     expect(config?.qrbox?.(1200, 844)).toEqual({ width: 319, height: 240 });
   });
+
+  it('clamps the scan box to the camera viewfinder size', async () => {
+    render(<ScannerHost scanBoxSize={{ width: 319, height: 240 }} />);
+
+    await waitFor(() => expect(mocks.start).toHaveBeenCalled());
+
+    const config = mocks.start.mock.calls[0]?.[1] as
+      | { qrbox?: (width: number, height: number) => { width: number; height: number } }
+      | undefined;
+
+    expect(config?.qrbox?.(200, 160)).toEqual({ width: 200, height: 160 });
+  });
+
+  it('reports camera start failures through the dedicated handler', async () => {
+    const cameraStartError = Object.assign(new Error('Camera failed'), { name: 'NotAllowedError' });
+    const handleCameraStartFailure = vi.fn();
+    const handleScanFailure = vi.fn();
+    mocks.start.mockRejectedValueOnce(cameraStartError);
+
+    render(<ScannerHost onCameraStartFailure={handleCameraStartFailure} onScanFailure={handleScanFailure} />);
+
+    await waitFor(() => expect(handleCameraStartFailure).toHaveBeenCalledWith(cameraStartError));
+    expect(handleScanFailure).not.toHaveBeenCalled();
+  });
+
+  it('uses jsQR first for Safari uploaded QR images', async () => {
+    const handleScanSuccess = vi.fn();
+    jsQrMocks.default.mockReturnValueOnce({ data: 'JSQR-CODE' });
+    stubSafariBrowser();
+    stubImageElement();
+    stubCanvas();
+
+    render(<FileScannerHost onScanSuccess={handleScanSuccess} />);
+    await waitFor(() => expect(mocks.start).toHaveBeenCalled());
+
+    fireEvent.click(screen.getByText('scan file'));
+
+    await waitFor(() => expect(handleScanSuccess).toHaveBeenCalledWith('JSQR-CODE'));
+    expect(jsQrMocks.default).toHaveBeenCalledWith(expect.any(Uint8ClampedArray), 600, 400, {
+      inversionAttempts: 'attemptBoth',
+    });
+    expect(mocks.scanFileV2).not.toHaveBeenCalled();
+  });
+
+  it('falls back to html5-qrcode for Safari uploaded files when jsQR does not decode a QR code', async () => {
+    const handleScanSuccess = vi.fn();
+    mocks.scanFileV2.mockResolvedValueOnce({ decodedText: 'BARCODE-CODE' });
+    stubSafariBrowser();
+    stubImageElement();
+    stubCanvas();
+
+    render(<FileScannerHost onScanSuccess={handleScanSuccess} />);
+    await waitFor(() => expect(mocks.start).toHaveBeenCalled());
+
+    fireEvent.click(screen.getByText('scan file'));
+
+    await waitFor(() => expect(handleScanSuccess).toHaveBeenCalledWith('BARCODE-CODE'));
+    expect(jsQrMocks.default).toHaveBeenCalled();
+    expect(mocks.scanFileV2).toHaveBeenCalled();
+  });
+
+  it('tries multiple image scales before falling back from Safari jsQR scanning', async () => {
+    const handleScanSuccess = vi.fn();
+    Array.from({ length: 8 }).forEach((_, index) => {
+      jsQrMocks.default.mockReturnValueOnce(index === 7 ? { data: 'SCALED-CODE' } : undefined);
+    });
+    stubSafariBrowser();
+    stubImageElement({ width: 4000, height: 3000 });
+    stubCanvas();
+
+    render(<FileScannerHost onScanSuccess={handleScanSuccess} />);
+    await waitFor(() => expect(mocks.start).toHaveBeenCalled());
+
+    fireEvent.click(screen.getByText('scan file'));
+
+    await waitFor(() => expect(handleScanSuccess).toHaveBeenCalledWith('SCALED-CODE'));
+    expect(jsQrMocks.default).toHaveBeenCalledTimes(8);
+  });
+
+  it('tries enhanced grayscale QR images for blurry Safari uploads', async () => {
+    const handleScanSuccess = vi.fn();
+    jsQrMocks.default.mockReturnValueOnce(undefined).mockReturnValueOnce({ data: 'ENHANCED-CODE' });
+    stubSafariBrowser();
+    stubImageElement();
+    stubCanvas();
+
+    render(<FileScannerHost onScanSuccess={handleScanSuccess} />);
+    await waitFor(() => expect(mocks.start).toHaveBeenCalled());
+
+    fireEvent.click(screen.getByText('scan file'));
+
+    await waitFor(() => expect(handleScanSuccess).toHaveBeenCalledWith('ENHANCED-CODE'));
+    expect(jsQrMocks.default).toHaveBeenCalledTimes(2);
+  });
 });