cursedbelt-core 2.3.0 → 2.5.0

package/dist/core/file-tree/fileTreeModel.d.ts

@@ -35,6 +35,21 @@ export interface FileTreeNode {
     /** Stable across re-derivation — it is the React key, the selection value and the drag id. */
     id: string;
     name: string;
+    /**
+     * Drawn right after the name, a step quieter — a file's extension, `.md`.
+     *
+     * For a consumer whose extension is DERIVED rather than part of the stored name
+     * (`apps/desk` works a note's suffix out from its format): *"show the extensions in the
+     * file tree like vscode does. I need to be able to tell what type each file is"*. Quieter
+     * because the name is what you scan FOR and the suffix is what you scan BY.
+     *
+     * 🔴 It is part of the name everywhere a person types one: {@link matchTypeahead} and
+     * {@link filterFileTree} match `name + suffix`, because what is drawn and what can be
+     * typed are the same string or they are a bug (*"I typed .json but it said 'Nothing is
+     * called that'"*). A rename opens on `name + suffix` with only the name selected — VS
+     * Code's field — and hands back whatever was typed, suffix and all.
+     */
+    suffix?: string;
     kind: FileTreeNodeKind;
     /** Folders only. A folder with `[]` is empty; a file's is ignored. */
     children?: readonly FileTreeNode[];
@@ -80,9 +95,26 @@ export interface FileTreeNode {
      *
      * The consumer's veto, for a rule the tree cannot know: collections uses it so a folder
      * cannot be dragged across album boundaries, which the server has no route for. Defaults
-     * to true for folders and is meaningless for files.
+     * to true for folders.
+     *
+     * 🔴 On a FILE it is the opposite switch, and it is opt-in: `true` makes the file a
+     * container of its own — a drop on the middle half of its row is `{ kind: 'into',
+     * parentId: <the file> }`. `apps/desk` is why: a workbook is a leaf in its tree, and
+     * dropping a sheet onto one makes the sheet one of its tabs (the owner, desk file `02`).
+     * The edges of the row, and the middle whenever {@link ResolveDropOptions.canDrop} vetoes
+     * the file, still mean *the folder the file is in* — so a column of such files is never a
+     * wall of rows that refuse everything that cannot go inside them. Absent or `false`, a
+     * file row means its folder along its whole height, exactly as before.
      */
     acceptsDrop?: boolean;
+    /**
+     * This row's own name matched a search the consumer ran — drawn a step heavier.
+     *
+     * For a consumer that narrows the tree itself (by content, not only by name) and keeps
+     * the folders on the way to each hit: the hits are what the eye is scanning for, and the
+     * folders kept around them are context. Omit it and nothing is emphasised.
+     */
+    matched?: boolean;
     /**
      * Whether this row can be picked up. Default true once `onMove` is wired.
      *
@@ -283,6 +315,8 @@ export declare function accessMarkCopy(access: FileTreeAccess | undefined, copy?
  * Typeahead is what makes a long tree usable without a search box — `bud` jumps to
  * `budget-2026` — and wrapping is what stops it dying at the bottom of the list.
  */
+/** The name as the row draws it — with its {@link FileTreeNode.suffix}. */
+export declare function drawnName(node: FileTreeNode): string;
 export declare function matchTypeahead(rows: readonly FileTreeRow[], query: string, fromIndex: number): number;
 /**
  * The tree narrowed to what matches, with the folders on the way to a match kept.

package/dist/core/file-tree/fileTreeModel.js

@@ -156,6 +156,16 @@ export function resolveDrop({ nodes, row, offsetRatio, dragId, allowReorder = fa
             return { target: null, refused: true, reason: lockedReason };
         return vetted({ target: { kind: 'into', parentId: target.id }, refused: false, reason: null });
     };
+    // A FILE the consumer opted in as a container takes the drop on the middle of its row —
+    // see `FileTreeNode.acceptsDrop`. Vetoed, it falls through to meaning its folder below.
+    if (target.kind === 'file' && !allowReorder && target.acceptsDrop === true && target.id !== dragId) {
+        const band = (1 - INTO_ZONE) / 2;
+        if (offsetRatio > band && offsetRatio < 1 - band) {
+            const into = vetted({ target: { kind: 'into', parentId: target.id }, refused: false, reason: null });
+            if (into.target)
+                return into;
+        }
+    }
     // A FILE row means "the folder that row is in" — what every file explorer does, and what
     // keeps a long list of files from being a wall of rows nothing can be dropped on.
     if (target.kind === 'file' && !allowReorder) {
@@ -298,6 +308,10 @@ export function accessMarkCopy(access, copy) {
  * Typeahead is what makes a long tree usable without a search box — `bud` jumps to
  * `budget-2026` — and wrapping is what stops it dying at the bottom of the list.
  */
+/** The name as the row draws it — with its {@link FileTreeNode.suffix}. */
+export function drawnName(node) {
+    return node.suffix ? `${node.name}${node.suffix}` : node.name;
+}
 export function matchTypeahead(rows, query, fromIndex) {
     if (!query)
         return -1;
@@ -305,7 +319,7 @@ export function matchTypeahead(rows, query, fromIndex) {
     for (let step = 1; step <= rows.length; step += 1) {
         const index = (fromIndex + step + rows.length) % rows.length;
         const row = rows[index];
-        if (row?.node.name.toLowerCase().startsWith(needle))
+        if (row && drawnName(row.node).toLowerCase().startsWith(needle))
             return index;
     }
     return -1;
@@ -322,7 +336,7 @@ export function filterFileTree(nodes, query) {
     if (!needle)
         return nodes;
     const keep = (node) => {
-        const hit = node.name.toLowerCase().includes(needle);
+        const hit = drawnName(node).toLowerCase().includes(needle);
         if (hit)
             return node;
         const kids = childrenOf(node)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cursedbelt-core",
-	"version": "2.3.0",
+	"version": "2.5.0",
 	"license": "ISC",
 	"type": "module",
 	"description": "Framework-agnostic core of the cursedbelt split — isomorphic domain logic. cwip below it, cursedbelt-server and cursedbelt (react) above it.",
@@ -18,11 +18,12 @@
 	"scripts": {
 		"clean": "rm -rf dist",
 		"typecheck": "tsc -p tsconfig.build.json --noEmit",
-		"test": "NODE_ENV=development bun test src",
+		"test": "NODE_ENV=development bun test --timeout 60000 --parallel=4 src",
 		"build": "bun run clean && tsc -p tsconfig.build.json",
 		"paths": "bun run scripts/paths.ts",
-		"verify": "bun run paths && bun run typecheck && bun run build && bun run test",
-		"prepublishOnly": "bun run verify"
+		"verify": "bun run gate",
+		"prepublishOnly": "bun run gate --force",
+		"gate": "bun run scripts/paths.ts --only gate.ts"
 	},
 	"files": [
 		"dist",
@@ -387,5 +388,25 @@
 		"zod": "4.4.3",
 		"@happy-dom/global-registrator": "^20.10.6",
 		"hono": "4.12.28"
+	},
+	"gate": {
+		"stages": [
+			{
+				"script": "paths"
+			},
+			{
+				"script": "typecheck"
+			},
+			{
+				"script": "build"
+			},
+			{
+				"script": "test",
+				"needs": [
+					"build"
+				],
+				"why": "build starts with `rm -rf dist`, and leafSubpathsImportNothing / shippedFilesAreTracked read dist/; racing it they read a directory that is not there yet"
+			}
+		]
 	}
 }

package/src/core/file-tree/fileTreeModel.spec.ts

@@ -13,6 +13,7 @@ import {
   resolveDrop,
   resolveKeyboardMove,
   describeDrop,
+  drawnName,
 } from './fileTreeModel.js';
 
 /**
@@ -234,6 +235,49 @@ describe('resolveDrop', () => {
   });
 });
 
+/**
+ * A FILE that takes drops INTO it — `acceptsDrop: true` on a file, which `apps/desk` sets on
+ * a workbook so a sheet dropped on it becomes one of its tabs.
+ */
+describe('resolveDrop onto a file that accepts drops', () => {
+  const book: FileTreeNode = { id: 'q3', name: 'Q3 Review', kind: 'file', acceptsDrop: true };
+  const nodes: FileTreeNode[] = [
+    folder('work', 'Work', [book, { id: 'report', name: 'report.csv', kind: 'file' }]),
+    { id: 'loose', name: 'loose.csv', kind: 'file' },
+  ];
+  const rows = flattenFileTree(nodes, []);
+  const on = (id: string, dragId: string, offsetRatio: number, canDrop?: (d: string | null, t: FileTreeDrop) => string | null) =>
+    resolveDrop({ nodes, row: rowFor(rows, id), offsetRatio, dragId, ...(canDrop ? { canDrop } : {}) });
+
+  test('the middle of its row is INTO the file', () => {
+    expect(on('q3', 'loose', 0.5).target).toEqual({ kind: 'into', parentId: 'q3' });
+  });
+
+  test('its edges still mean the folder it is in', () => {
+    expect(on('q3', 'loose', 0.1).target).toEqual({ kind: 'into', parentId: 'work' });
+    expect(on('q3', 'loose', 0.9).target).toEqual({ kind: 'into', parentId: 'work' });
+  });
+
+  test('🔴 a veto on the file falls back to its folder rather than refusing the row', () => {
+    const onlySheets = (dragId: string | null, target: FileTreeDrop) =>
+      target.kind === 'into' && target.parentId === 'q3' && dragId !== 'loose' ? 'Only a sheet can become a tab' : null;
+    expect(on('q3', 'report', 0.5, onlySheets).target).toEqual({ kind: 'into', parentId: 'work' });
+    expect(on('q3', 'loose', 0.5, onlySheets).target).toEqual({ kind: 'into', parentId: 'q3' });
+  });
+
+  test('a file never takes itself', () => {
+    expect(on('q3', 'q3', 0.5).target).toEqual({ kind: 'into', parentId: 'work' });
+  });
+
+  test('a file WITHOUT the flag means its folder along its whole height, as before', () => {
+    expect(on('report', 'loose', 0.5).target).toEqual({ kind: 'into', parentId: 'work' });
+  });
+
+  test('the chip names the file it is going into', () => {
+    expect(describeDrop(nodes, { kind: 'into', parentId: 'q3' })).toBe('Into Q3 Review');
+  });
+});
+
 /**
  * 🔴 The consumer's veto, which is the seam collections needs.
  *
@@ -483,3 +527,25 @@ describe('accessMarkCopy', () => {
     expect(accessMarkCopy(undefined)).toBe('');
   });
 });
+
+/** `suffix` — a derived extension, drawn and matched as part of the name. */
+describe('a suffix is part of the name a person types', () => {
+  const notes: FileTreeNode = { id: 'n', name: 'notes', suffix: '.md', kind: 'file' };
+  const nodes: FileTreeNode[] = [folder('docs', 'Docs', [notes]), { id: 'b', name: 'budget', kind: 'file' }];
+
+  test('drawnName carries it, and a node without one is its name', () => {
+    expect(drawnName(notes)).toBe('notes.md');
+    expect(drawnName({ id: 'b', name: 'budget', kind: 'file' })).toBe('budget');
+  });
+
+  test('typeahead matches through the dot', () => {
+    const rows = flattenFileTree(nodes, []);
+    expect(matchTypeahead(rows, 'notes.m', 0)).toBe(rows.findIndex((row) => row.node.id === 'n'));
+  });
+
+  test('a filter for the extension finds the file', () => {
+    const kept = filterFileTree(nodes, '.md');
+    expect(kept.map((node) => node.id)).toEqual(['docs']);
+    expect((kept[0]?.children ?? []).map((node) => node.id)).toEqual(['n']);
+  });
+});

package/src/core/file-tree/fileTreeModel.ts

@@ -38,6 +38,21 @@ export interface FileTreeNode {
   /** Stable across re-derivation — it is the React key, the selection value and the drag id. */
   id: string;
   name: string;
+  /**
+   * Drawn right after the name, a step quieter — a file's extension, `.md`.
+   *
+   * For a consumer whose extension is DERIVED rather than part of the stored name
+   * (`apps/desk` works a note's suffix out from its format): *"show the extensions in the
+   * file tree like vscode does. I need to be able to tell what type each file is"*. Quieter
+   * because the name is what you scan FOR and the suffix is what you scan BY.
+   *
+   * 🔴 It is part of the name everywhere a person types one: {@link matchTypeahead} and
+   * {@link filterFileTree} match `name + suffix`, because what is drawn and what can be
+   * typed are the same string or they are a bug (*"I typed .json but it said 'Nothing is
+   * called that'"*). A rename opens on `name + suffix` with only the name selected — VS
+   * Code's field — and hands back whatever was typed, suffix and all.
+   */
+  suffix?: string;
   kind: FileTreeNodeKind;
   /** Folders only. A folder with `[]` is empty; a file's is ignored. */
   children?: readonly FileTreeNode[];
@@ -83,9 +98,26 @@ export interface FileTreeNode {
    *
    * The consumer's veto, for a rule the tree cannot know: collections uses it so a folder
    * cannot be dragged across album boundaries, which the server has no route for. Defaults
-   * to true for folders and is meaningless for files.
+   * to true for folders.
+   *
+   * 🔴 On a FILE it is the opposite switch, and it is opt-in: `true` makes the file a
+   * container of its own — a drop on the middle half of its row is `{ kind: 'into',
+   * parentId: <the file> }`. `apps/desk` is why: a workbook is a leaf in its tree, and
+   * dropping a sheet onto one makes the sheet one of its tabs (the owner, desk file `02`).
+   * The edges of the row, and the middle whenever {@link ResolveDropOptions.canDrop} vetoes
+   * the file, still mean *the folder the file is in* — so a column of such files is never a
+   * wall of rows that refuse everything that cannot go inside them. Absent or `false`, a
+   * file row means its folder along its whole height, exactly as before.
    */
   acceptsDrop?: boolean;
+  /**
+   * This row's own name matched a search the consumer ran — drawn a step heavier.
+   *
+   * For a consumer that narrows the tree itself (by content, not only by name) and keeps
+   * the folders on the way to each hit: the hits are what the eye is scanning for, and the
+   * folders kept around them are context. Omit it and nothing is emphasised.
+   */
+  matched?: boolean;
   /**
    * Whether this row can be picked up. Default true once `onMove` is wired.
    *
@@ -330,6 +362,16 @@ export function resolveDrop({
     return vetted({ target: { kind: 'into', parentId: target.id }, refused: false, reason: null });
   };
 
+  // A FILE the consumer opted in as a container takes the drop on the middle of its row —
+  // see `FileTreeNode.acceptsDrop`. Vetoed, it falls through to meaning its folder below.
+  if (target.kind === 'file' && !allowReorder && target.acceptsDrop === true && target.id !== dragId) {
+    const band = (1 - INTO_ZONE) / 2;
+    if (offsetRatio > band && offsetRatio < 1 - band) {
+      const into = vetted({ target: { kind: 'into', parentId: target.id }, refused: false, reason: null });
+      if (into.target) return into;
+    }
+  }
+
   // A FILE row means "the folder that row is in" — what every file explorer does, and what
   // keeps a long list of files from being a wall of rows nothing can be dropped on.
   if (target.kind === 'file' && !allowReorder) {
@@ -503,6 +545,11 @@ export function accessMarkCopy(
  * Typeahead is what makes a long tree usable without a search box — `bud` jumps to
  * `budget-2026` — and wrapping is what stops it dying at the bottom of the list.
  */
+/** The name as the row draws it — with its {@link FileTreeNode.suffix}. */
+export function drawnName(node: FileTreeNode): string {
+  return node.suffix ? `${node.name}${node.suffix}` : node.name;
+}
+
 export function matchTypeahead(
   rows: readonly FileTreeRow[],
   query: string,
@@ -513,7 +560,7 @@ export function matchTypeahead(
   for (let step = 1; step <= rows.length; step += 1) {
     const index = (fromIndex + step + rows.length) % rows.length;
     const row = rows[index];
-    if (row?.node.name.toLowerCase().startsWith(needle)) return index;
+    if (row && drawnName(row.node).toLowerCase().startsWith(needle)) return index;
   }
   return -1;
 }
@@ -532,7 +579,7 @@ export function filterFileTree(
   const needle = query.trim().toLowerCase();
   if (!needle) return nodes;
   const keep = (node: FileTreeNode): FileTreeNode | null => {
-    const hit = node.name.toLowerCase().includes(needle);
+    const hit = drawnName(node).toLowerCase().includes(needle);
     if (hit) return node;
     const kids = childrenOf(node)
       .map(keep)