cursedbelt 5.30.0 → 5.32.0

package/src/react/components/DataTable/DataTable.spec.tsx

@@ -536,3 +536,19 @@ describe('TableViewToggle', () => {
     expect(container.textContent).toContain('Cards');
   });
 });
+
+// forge task 2396: hiding the pager used to leave the paging on, so row 51 and beyond were
+// simply not there — with no control to reach them.
+describe('hidePagination shows every row', () => {
+  const MANY: Person[] = Array.from({ length: 60 }, (_, i) => ({ name: `p${String(i).padStart(2, '0')}`, age: i }));
+
+  test('60 rows with no pager render 60 rows', () => {
+    const { container } = render(<DataTable columns={COLUMNS} data={MANY} hidePagination />);
+    expect(bodyRows(container).length).toBe(60);
+  });
+
+  test('with the pager, the first page is still 50', () => {
+    const { container } = render(<DataTable columns={COLUMNS} data={MANY} />);
+    expect(bodyRows(container).length).toBe(50);
+  });
+});

package/src/react/components/DataTable/DataTable.tsx

@@ -1270,7 +1270,11 @@ export function DataTable<TRow extends Record<string, unknown>>({
     getFilteredRowModel: serverSide || serverWindow ? undefined : getFilteredRowModel(),
     // 🔴 `virtualEnabled` too, not only `serverSide`. See the note where the flag is
     // computed: a paginated virtualizer sizes its spacer from one PAGE.
-    getPaginationRowModel: serverSide || virtualEnabled ? undefined : getPaginationRowModel(),
+    // 🔴 And `hidePagination` (forge task 2396): hiding the pager used to leave the paging ON,
+    // so a table past `pageSize` rows (50) silently showed its first page with no control to
+    // reach the rest — binary-server's run history and station's metric tables among them.
+    // A table with no pager shows every row; that is what "no pager" means.
+    getPaginationRowModel: serverSide || paginationHidden ? undefined : getPaginationRowModel(),
     // TanStack's built-in auto-reset fires `resetPageIndex()` on EVERY `data`
     // identity change (see `getCoreRowModel`'s memo deps), not just on filter/sort
     // changes — any live-polling table (this one included: rows are re-derived

package/src/react/components/PromptDialog.spec.tsx

@@ -1,5 +1,6 @@
 import { afterEach, describe, expect, test } from 'bun:test';
 import { cleanup, fireEvent, render, waitFor } from '@testing-library/react';
+import { confirm } from '../confirm.js';
 import { prompt } from '../prompt.js';
 import { PromptDialog } from './PromptDialog.js';
 
@@ -64,7 +65,7 @@ describe('PromptDialog', () => {
           }}
         />,
     );
-    fireEvent.click(body().querySelector('[data-cb-cancel]') as HTMLElement);
+    fireEvent.keyDown(dialogs()[0] as HTMLElement, { key: 'Escape' });
     expect(cancelled).toBe(1);
     expect(submitted).toBe(0);
   });
@@ -116,3 +117,30 @@ describe('prompt() imperative', () => {
     expect(await result).toBeNull();
   });
 });
+
+// The dialogs portal to <body>, outside any subtree an app scopes the belt's preflight under
+// (binary-server's admin: `cb-scope`), so the class has to reach the content box itself.
+describe('className reaches the portalled dialog (forge task 2380)', () => {
+  const cancelButton = () =>
+    waitFor(() => {
+      const b = body().querySelector('[data-cb-cancel]') as HTMLButtonElement | null;
+      if (!b) throw new Error('not yet');
+      return b;
+    });
+
+  test('prompt({ className }) puts it on the dialog', async () => {
+    const typed = prompt({ title: 'Type it', className: 'cb-scope' });
+    const cancel = await cancelButton();
+    expect(cancel.closest('[role="dialog"]')?.classList.contains('cb-scope')).toBe(true);
+    fireEvent.click(cancel);
+    expect(await typed).toBeNull();
+  });
+
+  test('confirm({ className }) puts it on the dialog', async () => {
+    const asked = confirm({ title: 'Sure?', className: 'cb-scope' });
+    const cancel = await cancelButton();
+    expect(cancel.closest('[role="dialog"], [role="alertdialog"]')?.classList.contains('cb-scope')).toBe(true);
+    fireEvent.click(cancel);
+    expect(await asked).toBe(false);
+  });
+});

package/src/react/components/PromptDialog.tsx

@@ -16,6 +16,9 @@ export interface PromptDialogProps {
   cancelLabel?: string;
   /** Spinner on the confirm button while an async `onSubmit` runs (caller-controlled). */
   loading?: boolean;
+  /** Added to the dialog's content box — an app that scopes the belt's preflight under a class
+   *  (binary-server's admin: `cb-scope`) passes it here, because the dialog portals to <body>. */
+  className?: string;
 }
 
 /**
@@ -37,6 +40,7 @@ export function PromptDialog({
   confirmLabel = 'OK',
   cancelLabel = 'Cancel',
   loading = false,
+  className,
 }: PromptDialogProps) {
   const [value, setValue] = useState(defaultValue);
   const inputRef = useRef<HTMLInputElement>(null);
@@ -58,6 +62,7 @@ export function PromptDialog({
           'rounded-xl border border-border bg-popover p-6 text-popover-foreground shadow-overlay',
           'data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:zoom-in-95',
           'data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95',
+          className,
         )}
         onOpenAutoFocus={(e) => {
           e.preventDefault();

package/src/react/file-tree/FileTree.spec.tsx

@@ -1553,6 +1553,140 @@ describe('the clipboard', () => {
     expect(cutEvent.defaultPrevented).toBe(false);
     expect(cut.container.querySelectorAll('[data-cut]')).toHaveLength(0);
   });
+
+  /**
+   * Task 2371 — Finder has ONE clipboard, so the newest copy wins. ⌘C a row, later ⌘⇧4 + ⌘C a
+   * screenshot, then ⌘V on a row: the screenshot must reach the consumer's paste (desk files
+   * it into the folder), not be swallowed by a row copy held since.
+   */
+  describe('🔴 the newest copy wins', () => {
+    const written: string[] = [];
+    let restore: () => void = () => undefined;
+    const withSystemClipboard = () => {
+      const had = Object.getOwnPropertyDescriptor(navigator, 'clipboard');
+      Object.defineProperty(navigator, 'clipboard', {
+        configurable: true,
+        value: {
+          writeText: async (text: string) => {
+            written.push(text);
+          },
+        },
+      });
+      restore = () => {
+        if (had) Object.defineProperty(navigator, 'clipboard', had);
+        else delete (navigator as { clipboard?: unknown }).clipboard;
+      };
+    };
+    afterEach(() => {
+      restore();
+      written.length = 0;
+    });
+
+    /** A consumer around the tree that takes pasted files, the way desk's LibraryTree does. */
+    const hosted = (props: Partial<React.ComponentProps<typeof FileTree>>, heard: string[]) =>
+      render(
+        <div
+          onPaste={(event) => {
+            for (const file of Array.from(event.clipboardData.files)) heard.push(file.name);
+          }}
+        >
+          <FileTree nodes={TREE} selectedId={null} onSelect={() => undefined} {...props} />
+        </div>,
+      );
+
+    const pressV = (name: string) => {
+      const row = focusRow(name);
+      const key = new KeyboardEvent('keydown', {
+        key: 'v',
+        metaKey: true,
+        bubbles: true,
+        cancelable: true,
+      });
+      row.dispatchEvent(key);
+      return { row, key };
+    };
+
+    const shot = new File([new Uint8Array([137, 80, 78, 71])], 'Pasted image.png', {
+      type: 'image/png',
+    });
+    const clipboardWith = (text: string, files: File[] = []) => ({
+      files,
+      items: files.map(() => ({ kind: 'file' })),
+      getData: (type: string) => (type === 'text/plain' ? text : ''),
+    });
+
+    test('⌘C puts the rows’ names on the system clipboard as well', async () => {
+      withSystemClipboard();
+      tree({ selectedIds: ['dinos', 'travels'], onSelectionChange: () => undefined, onCopy: () => undefined });
+      fireEvent.keyDown(focusRow('Dinos'), { key: 'c', metaKey: true });
+      await act(async () => undefined);
+      expect(written).toEqual(['Dinos\nTravels']);
+    });
+
+    test('🔴 a screenshot copied after a row ⌘C reaches the consumer, and the row copy is put down', async () => {
+      withSystemClipboard();
+      const copied: unknown[] = [];
+      const heard: string[] = [];
+      hosted({ onCopy: (ids) => copied.push(ids) }, heard);
+      fireEvent.keyDown(focusRow('Dinos'), { key: 'c', metaKey: true });
+      await act(async () => undefined);
+
+      const { row, key } = pressV('Simpsons');
+      // Left to the browser, or no `paste` event would fire at all.
+      expect(key.defaultPrevented).toBe(false);
+      fireEvent.paste(row, { clipboardData: clipboardWith('', [shot]) });
+      await act(async () => new Promise((done) => setTimeout(done, 5)));
+      expect(heard).toEqual(['Pasted image.png']);
+      expect(copied).toEqual([]);
+
+      // Put down, not merely skipped once: the next ⌘V is not the tree's either.
+      const again = pressV('screencaps');
+      await act(async () => new Promise((done) => setTimeout(done, 5)));
+      expect(again.key.defaultPrevented).toBe(false);
+      expect(copied).toEqual([]);
+    });
+
+    test('🔴 a held ⌘X is put down by newer text the same way — desk’s tree has cut, not copy', async () => {
+      withSystemClipboard();
+      const moved: unknown[] = [];
+      const { container } = hosted({ onMove: (id) => moved.push(id) }, []);
+      fireEvent.keyDown(focusRow('Dinos'), { key: 'x', metaKey: true });
+      await act(async () => undefined);
+      const { row } = pressV('Simpsons');
+      fireEvent.paste(row, { clipboardData: clipboardWith('something copied since') });
+      await act(async () => new Promise((done) => setTimeout(done, 5)));
+      expect(moved).toEqual([]);
+      expect(container.querySelectorAll('[data-cut]')).toHaveLength(0);
+    });
+
+    test('🔴 the rows’ own names still on the clipboard mean the rows ARE newest — pasted, and the consumer never hears it', async () => {
+      withSystemClipboard();
+      const copied: Array<[readonly string[], unknown]> = [];
+      const heard: string[] = [];
+      hosted({ onCopy: (ids, drop) => copied.push([ids, drop]) }, heard);
+      fireEvent.keyDown(focusRow('Dinos'), { key: 'c', metaKey: true });
+      await act(async () => undefined);
+      const { row } = pressV('Simpsons');
+      const paste = fireEvent.paste(row, { clipboardData: clipboardWith('Dinos') });
+      // `fireEvent` returns false when the event was cancelled.
+      expect(paste).toBe(false);
+      await act(async () => new Promise((done) => setTimeout(done, 5)));
+      // Once — the fallback timer must not paste the same keypress a second time.
+      expect(copied).toEqual([[['dinos'], { kind: 'into', parentId: 'simpsons' }]]);
+      expect(heard).toEqual([]);
+    });
+
+    test('an engine that sends no `paste` to a row still pastes the rows, from the keypress', async () => {
+      withSystemClipboard();
+      const copied: unknown[] = [];
+      tree({ onCopy: (ids) => copied.push(ids) });
+      fireEvent.keyDown(focusRow('Dinos'), { key: 'c', metaKey: true });
+      await act(async () => undefined);
+      pressV('Simpsons');
+      await act(async () => new Promise((done) => setTimeout(done, 5)));
+      expect(copied).toEqual([['dinos']]);
+    });
+  });
 });
 
 /**
@@ -2046,3 +2180,74 @@ describe('every row carries its id', () => {
     ]);
   });
 });
+
+/*
+ * `onDropOutside` — rows carried out of the tree onto something drawn beside it.
+ *
+ * happy-dom lays nothing out (see the header), so the tree's own box is given one here and
+ * every row stays a zero rect: that is enough to tell "released outside the tree" from
+ * "released inside it", which is the whole decision this prop adds. Where inside a drop
+ * lands is the model's arithmetic, tested in `fileTreeModel.spec.ts`.
+ */
+describe('onDropOutside — a drag let go beside the tree', () => {
+  const boxTree = (container: HTMLElement) => {
+    const root = container.querySelector('.cbft') as HTMLElement;
+    root.getBoundingClientRect = () =>
+      ({ left: 0, top: 0, right: 200, bottom: 400, width: 200, height: 400, x: 0, y: 0 }) as DOMRect;
+  };
+  const dragDinos = (to: { x: number; y: number }) => {
+    const row = screen.getByText('Dinos').closest('[role="treeitem"]') as HTMLElement;
+    fireEvent.pointerDown(row, { button: 0, clientX: 40, clientY: 30, pointerId: 1, pointerType: 'mouse' });
+    fireEvent.pointerMove(row, { clientX: to.x, clientY: to.y, pointerId: 1, pointerType: 'mouse' });
+    return row;
+  };
+
+  test('released outside, the rows and the point go to the consumer — and nothing moves', () => {
+    const onDropOutside = jest.fn();
+    const onMove = jest.fn();
+    const { container } = tree({ onMove, onDropOutside });
+    boxTree(container);
+    const row = dragDinos({ x: 500, y: 60 });
+    expect(container.querySelector('.cbft-chip-where')?.textContent).toBe('Drop to add it here');
+    fireEvent.pointerUp(row, { clientX: 500, clientY: 60, pointerId: 1, pointerType: 'mouse' });
+    expect(onDropOutside).toHaveBeenCalledTimes(1);
+    expect(onDropOutside.mock.calls[0]).toEqual([['dinos'], { clientX: 500, clientY: 60 }]);
+    expect(onMove).not.toHaveBeenCalled();
+  });
+
+  test('released inside, it is a rearrange as it always was — the consumer hears nothing', () => {
+    const onDropOutside = jest.fn();
+    const { container } = tree({ onMove: () => undefined, onDropOutside });
+    boxTree(container);
+    const row = dragDinos({ x: 100, y: 60 });
+    fireEvent.pointerUp(row, { clientX: 100, clientY: 60, pointerId: 1, pointerType: 'mouse' });
+    expect(onDropOutside).not.toHaveBeenCalled();
+  });
+
+  test('describeDropOutside names the place, and null refuses it — the rows go back', () => {
+    const onDropOutside = jest.fn();
+    const { container } = tree({
+      onDropOutside,
+      describeDropOutside: ({ clientX }) => (clientX > 400 ? 'Onto the canvas' : null),
+    });
+    boxTree(container);
+    const row = dragDinos({ x: 300, y: 60 });
+    const chip = () => container.querySelector('.cbft-chip') as HTMLElement;
+    expect(chip().getAttribute('data-refused')).toBe('true');
+    expect(chip().textContent).toContain('Nothing here takes it');
+    fireEvent.pointerUp(row, { clientX: 300, clientY: 60, pointerId: 1, pointerType: 'mouse' });
+    expect(onDropOutside).not.toHaveBeenCalled();
+
+    const again = dragDinos({ x: 600, y: 60 });
+    expect(chip().textContent).toContain('Onto the canvas');
+    fireEvent.pointerUp(again, { clientX: 600, clientY: 60, pointerId: 1, pointerType: 'mouse' });
+    expect(onDropOutside).toHaveBeenCalledTimes(1);
+  });
+
+  test('without it, a tree that cannot be rearranged starts no drag at all', () => {
+    const { container } = tree();
+    boxTree(container);
+    dragDinos({ x: 500, y: 60 });
+    expect(container.querySelector('.cbft-chip')).toBeNull();
+  });
+});