blots-editor 0.0.14 → 0.0.16

package/asset/language/en.json

@@ -19,6 +19,10 @@
   "toolbar.fileTree": "File Tree",
   "toolbar.save": "Save",
   "toolbar.settings": "Settings",
+  "fileTree.scanning": "Scanning...",
+  "fileTree.noDir": "No directory",
+  "fileTree.fail": "Scan failed",
+  "fileTree.unsaved": "Unsaved changes",
   "editor.setting.title": "Menu",
   "editor.setting.openSetting": "Settings",
   "editor.setting.exit": "Exit",

package/asset/language/zh.json

@@ -19,6 +19,10 @@
   "toolbar.fileTree": "文件树",
   "toolbar.save": "保存",
   "toolbar.settings": "设置",
+  "fileTree.scanning": "正在扫描...",
+  "fileTree.noDir": "没有目录",
+  "fileTree.fail": "扫描失败",
+  "fileTree.unsaved": "未保存的更改",
   "editor.setting.title": "菜单",
   "editor.setting.openSetting": "设置",
   "editor.setting.exit": "退出",

package/dist/core/document/document.d.ts

@@ -20,6 +20,23 @@ export declare class Document {
     private _wrapWidth;
     private _viewScrollTop;
     private _scrollRemainder;
+    /**
+     * Per-line soft-wrap segment cache. Segments are derived purely from
+     * `_lines` + `_wrapWidth`, but recomputing them is expensive (binary
+     * searches + per-character tab expansion), and the render path queries
+     * them O(viewport) times per frame — so identical inputs must not be
+     * recomputed. null while invalidated; rebuilt lazily on first use.
+     */
+    private _segmentCache;
+    /**
+     * Prefix sums of segment counts: `prefix[i]` = visual lines occupied by
+     * the first `i` logical lines (so `prefix[line]` is the global visual
+     * line where logical line `line` starts). Lets `visualLineAt` /
+     * `cursorVisualLine` / `visualLineCount` answer in O(log n)/O(1)
+     * instead of scanning every line. Invalidated together with
+     * `_segmentCache`.
+     */
+    private _segPrefix;
     readonly indentWidth: number;
     constructor(text: string, options?: DocumentOptions);
     get lineCount(): number;
@@ -45,14 +62,36 @@ export declare class Document {
     get wrapWidth(): number;
     /** Set the soft-wrap width (clamped to at least 1 cell). */
     setWrapWidth(width: number): void;
-    /** The soft-wrap segments of one logical line (an empty line is one empty segment). */
+    /**
+     * The soft-wrap segments of one logical line (an empty line is one empty
+     * segment). Cached: the render path queries these O(viewport) times per
+     * frame, and every hit would otherwise re-run `segmentFrom` (binary
+     * search + per-character tab expansion) on unchanged input.
+     */
     private lineSegments;
+    /**
+     * Prefix sums of segment counts, built lazily from the segment cache.
+     * Both caches are invalidated together (see {@link invalidateIndex}), so
+     * they can never disagree once built.
+     */
+    private buildSegmentPrefix;
+    /**
+     * Drop the segment cache and the visual-line index. Every mutation entry
+     * point (`setText`, `setLine`, `insertLineAt`, `removeLineAt`, and a
+     * *changed* `setWrapWidth`) must call this, or queries would keep serving
+     * stale segments. Rebuilding is lazy — the next query pays O(total
+     * segments) once.
+     */
+    private invalidateIndex;
     /** Total number of visual (soft-wrapped) lines across the document. */
     get visualLineCount(): number;
     /**
      * Map a global visual line to its logical line and the segment's logical
      * span. `first` marks the segment that starts at the logical line start
-     * (the one that carries the line number).
+     * (the one that carries the line number). Binary search over the segment
+     * prefix sums keeps this O(log n) — the render loop calls it once per
+     * visible line, so a linear scan here would be O(viewport × lines) every
+     * frame.
      */
     visualLineAt(vline: number): {
         line: number;

package/dist/core/document/document.js

@@ -20,6 +20,23 @@ export class Document {
     _viewScrollTop = null;
     // Fractional view-scroll remainder, so e.g. 3.5 cells/notch scrolls 3,4,3,4…
     _scrollRemainder = 0;
+    /**
+     * Per-line soft-wrap segment cache. Segments are derived purely from
+     * `_lines` + `_wrapWidth`, but recomputing them is expensive (binary
+     * searches + per-character tab expansion), and the render path queries
+     * them O(viewport) times per frame — so identical inputs must not be
+     * recomputed. null while invalidated; rebuilt lazily on first use.
+     */
+    _segmentCache = null;
+    /**
+     * Prefix sums of segment counts: `prefix[i]` = visual lines occupied by
+     * the first `i` logical lines (so `prefix[line]` is the global visual
+     * line where logical line `line` starts). Lets `visualLineAt` /
+     * `cursorVisualLine` / `visualLineCount` answer in O(log n)/O(1)
+     * instead of scanning every line. Invalidated together with
+     * `_segmentCache`.
+     */
+    _segPrefix = null;
     indentWidth;
     constructor(text, options = {}) {
         this._lines = text.split(/\r?\n/).map((t) => new TextLine(t));
@@ -56,6 +73,7 @@ export class Document {
         this._scrollTop = 0;
         this._viewScrollTop = null;
         this._scrollRemainder = 0;
+        this.invalidateIndex();
     }
     get cursor() {
         const line = this._lines[this._cursor.line];
@@ -74,68 +92,123 @@ export class Document {
     }
     /** Set the soft-wrap width (clamped to at least 1 cell). */
     setWrapWidth(width) {
-        this._wrapWidth = Math.max(1, width);
+        const w = Math.max(1, width);
+        // The view calls this on every render with the measured width; only a
+        // real change invalidates the cache, or it would be rebuilt (and
+        // discarded) every frame.
+        if (w !== this._wrapWidth) {
+            this._wrapWidth = w;
+            this.invalidateIndex();
+        }
     }
-    /** The soft-wrap segments of one logical line (an empty line is one empty segment). */
+    /**
+     * The soft-wrap segments of one logical line (an empty line is one empty
+     * segment). Cached: the render path queries these O(viewport) times per
+     * frame, and every hit would otherwise re-run `segmentFrom` (binary
+     * search + per-character tab expansion) on unchanged input.
+     */
     lineSegments(line) {
+        const cached = this._segmentCache?.[line];
+        if (cached) {
+            return cached;
+        }
         const tl = this._lines[line];
+        const segs = [];
         if (tl.text.length === 0) {
-            return [{ start: 0, end: 0, text: "" }];
+            segs.push({ start: 0, end: 0, text: "" });
         }
-        const segs = [];
-        let segVisual = 0;
-        let segStart = 0;
-        while (segStart < tl.text.length) {
-            const seg = tl.segmentFrom(segVisual, this._wrapWidth);
-            segs.push({ start: segStart, end: seg.endLogical, text: seg.text });
-            if (seg.text === "") {
-                break;
+        else {
+            let segVisual = 0;
+            let segStart = 0;
+            while (segStart < tl.text.length) {
+                const seg = tl.segmentFrom(segVisual, this._wrapWidth);
+                segs.push({ start: segStart, end: seg.endLogical, text: seg.text });
+                if (seg.text === "") {
+                    break;
+                }
+                segStart = seg.endLogical;
+                segVisual = seg.endVisual;
             }
-            segStart = seg.endLogical;
-            segVisual = seg.endVisual;
         }
+        if (!this._segmentCache) {
+            this._segmentCache = [];
+        }
+        this._segmentCache[line] = segs;
         return segs;
     }
-    /** Total number of visual (soft-wrapped) lines across the document. */
-    get visualLineCount() {
+    /**
+     * Prefix sums of segment counts, built lazily from the segment cache.
+     * Both caches are invalidated together (see {@link invalidateIndex}), so
+     * they can never disagree once built.
+     */
+    buildSegmentPrefix() {
+        if (this._segPrefix) {
+            return this._segPrefix;
+        }
+        const prefix = [0];
         let total = 0;
         for (let i = 0; i < this._lines.length; i++) {
             total += this.lineSegments(i).length;
+            prefix.push(total);
         }
-        return total;
+        this._segPrefix = prefix;
+        return prefix;
+    }
+    /**
+     * Drop the segment cache and the visual-line index. Every mutation entry
+     * point (`setText`, `setLine`, `insertLineAt`, `removeLineAt`, and a
+     * *changed* `setWrapWidth`) must call this, or queries would keep serving
+     * stale segments. Rebuilding is lazy — the next query pays O(total
+     * segments) once.
+     */
+    invalidateIndex() {
+        this._segmentCache = null;
+        this._segPrefix = null;
+    }
+    /** Total number of visual (soft-wrapped) lines across the document. */
+    get visualLineCount() {
+        return this.buildSegmentPrefix()[this._lines.length];
     }
     /**
      * Map a global visual line to its logical line and the segment's logical
      * span. `first` marks the segment that starts at the logical line start
-     * (the one that carries the line number).
+     * (the one that carries the line number). Binary search over the segment
+     * prefix sums keeps this O(log n) — the render loop calls it once per
+     * visible line, so a linear scan here would be O(viewport × lines) every
+     * frame.
      */
     visualLineAt(vline) {
         if (vline < 0) {
             return null;
         }
-        let remaining = vline;
-        for (let line = 0; line < this._lines.length; line++) {
-            const segs = this.lineSegments(line);
-            if (remaining < segs.length) {
-                return {
-                    line,
-                    start: segs[remaining].start,
-                    end: segs[remaining].end,
-                    first: remaining === 0,
-                    text: segs[remaining].text,
-                };
+        const prefix = this.buildSegmentPrefix();
+        if (vline >= prefix[this._lines.length]) {
+            return null;
+        }
+        // Largest line index whose prefix start is <= vline.
+        let lo = 0;
+        let hi = this._lines.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (prefix[mid] <= vline) {
+                lo = mid;
+            }
+            else {
+                hi = mid - 1;
             }
-            remaining -= segs.length;
         }
-        return null;
+        const seg = this.lineSegments(lo)[vline - prefix[lo]];
+        return {
+            line: lo,
+            start: seg.start,
+            end: seg.end,
+            first: vline === prefix[lo],
+            text: seg.text,
+        };
     }
     /** Global visual line the cursor sits on. */
     get cursorVisualLine() {
         const { line, logical } = this._cursor;
-        let v = 0;
-        for (let i = 0; i < line; i++) {
-            v += this.lineSegments(i).length;
-        }
         const segs = this.lineSegments(line);
         let idx = 0;
         // A cursor exactly on a segment boundary belongs to the segment
@@ -144,7 +217,7 @@ export class Document {
         while (idx < segs.length - 1 && logical >= segs[idx + 1].start) {
             idx++;
         }
-        return v + idx;
+        return this.buildSegmentPrefix()[line] + idx;
     }
     /** Visual offset of the cursor within its current soft-wrap segment. */
     get cursorSegmentVisual() {
@@ -175,14 +248,18 @@ export class Document {
     }
     setLine(i, text) {
         this._lines[i] = new TextLine(text);
+        this.invalidateIndex();
     }
     /** Insert a line at index `i` (0 <= i <= lineCount), shifting the rest down. */
     insertLineAt(i, text) {
         this._lines.splice(i, 0, new TextLine(text));
+        this.invalidateIndex();
     }
     /** Remove line `i` and return its text. */
     removeLineAt(i) {
-        return this._lines.splice(i, 1)[0].text;
+        const removed = this._lines.splice(i, 1)[0].text;
+        this.invalidateIndex();
+        return removed;
     }
     /** Set the cursor, clamping out-of-range values (line to `[0, lineCount-1]`, column to end of line). */
     setCursor(line, logical) {

package/dist/core/{file-tree-model.d.ts → io/file-tree-model.d.ts}

@@ -1,8 +1,17 @@
-import type { FileTreeSettings } from "./settings/schema.js";
+import type { FileTreeSettings } from "../settings/schema.js";
 /** Clear the scan cache (refresh button, tests). */
 export declare function clearFileTreeCache(): void;
+export type FileTreeState = {
+    ok: true;
+    node: FileNode;
+    path: string;
+} | {
+    fail: true;
+} | {
+    scanning: true;
+};
 /** Scan a directory, serving repeat calls for the same root from the cache. */
-export declare function scanDirectoryCached(root: string): FileNode | null;
+export declare function scanDirectoryCached(root: string): Promise<FileTreeState>;
 /** One entry of the scanned tree. Directories carry their children. */
 export type FileNode = {
     /** Entry name (not the full path). */
@@ -24,7 +33,7 @@ export declare function resolveFileTreeRoot(settings: FileTreeSettings, startupD
  *
  * @returns The root node, or null when the directory cannot be read.
  */
-export declare function scanDirectory(root: string): FileNode | null;
+export declare function scanDirectory(root: string): Promise<FileNode | null>;
 /** One visible tree row produced by flattening with expansion state. */
 export type TreeRow = {
     node: FileNode;

package/dist/core/{file-tree-model.js → io/file-tree-model.js}

@@ -1,4 +1,4 @@
-import { readdirSync } from "node:fs";
+import fs from 'node:fs/promises';
 import { homedir } from "node:os";
 import { join } from "node:path";
 /**
@@ -13,16 +13,27 @@ export function clearFileTreeCache() {
     scanCache.clear();
 }
 /** Scan a directory, serving repeat calls for the same root from the cache. */
-export function scanDirectoryCached(root) {
+export async function scanDirectoryCached(root) {
     const hit = scanCache.get(root);
     if (hit) {
-        return hit;
+        return {
+            ok: true,
+            node: hit,
+            path: root
+        };
     }
-    const tree = scanDirectory(root);
+    const tree = await scanDirectory(root);
     if (tree) {
         scanCache.set(root, tree);
+        return {
+            ok: true,
+            node: tree,
+            path: root
+        };
     }
-    return tree;
+    return {
+        fail: true
+    };
 }
 /** Directories skipped at every depth (dependency dirs, VCS internals). */
 const SKIP_DIRS = new Set(["node_modules", ".git", "dist", ".next", ".cache"]);
@@ -47,8 +58,8 @@ export function resolveFileTreeRoot(settings, startupDir) {
  *
  * @returns The root node, or null when the directory cannot be read.
  */
-export function scanDirectory(root) {
-    const entries = readDirSafe(root);
+export async function scanDirectory(root) {
+    const entries = await readDirSafe(root);
     if (!entries) {
         return null;
     }
@@ -63,7 +74,7 @@ export function scanDirectory(root) {
             if (SKIP_DIRS.has(name)) {
                 continue;
             }
-            nodes.push({ name, path, isDir: true, children: scanChildren(path) });
+            nodes.push({ name, path, isDir: true, children: await scanChildren(path) });
         }
         else if (entry.isFile()) {
             nodes.push({ name, path, isDir: false });
@@ -74,14 +85,14 @@ export function scanDirectory(root) {
     nodes.sort((a, b) => a.isDir === b.isDir ? (a.name < b.name ? -1 : a.name > b.name ? 1 : 0) : a.isDir ? -1 : 1);
     return { name: root, path: root, isDir: true, children: nodes };
 }
-function scanChildren(dir) {
-    const child = scanDirectory(dir);
+async function scanChildren(dir) {
+    const child = await scanDirectory(dir);
     return child?.children;
 }
 /** Read a directory without throwing; null when unreadable (EACCES etc.). */
-function readDirSafe(path) {
+async function readDirSafe(path) {
     try {
-        return readdirSync(path, { withFileTypes: true });
+        return await fs.readdir(path, { withFileTypes: true });
     }
     catch {
         return null;

package/dist/core/{session.d.ts → io/session.d.ts}

@@ -1,4 +1,4 @@
-import { EditorController, type EditorOptions } from "./editor-controller.js";
+import { EditorController, type EditorOptions } from "../editor-controller.js";
 export type ActionResult = {
     ok: true;
 } | {

package/dist/core/{session.js → io/session.js}

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { readFileSync, writeFileSync } from "node:fs";
 import { basename } from "node:path";
-import { EditorController } from "./editor-controller.js";
+import { EditorController } from "../editor-controller.js";
 /**
  * File-session coordinator shared by the editor, file tree, and toolbar.
  *

package/dist/index.js

@@ -2,11 +2,11 @@
 import { render } from "ink";
 import React from "react";
 import { CurrentScreen, KeyboardProvider, LanguageProvider, registerComponent, ScenarioManagementProvider, } from "ink-cartridge";
-import { resources } from "./i18n-resources.js";
+import { resources } from "./utils/view/i18n-resources.js";
 import { settingsStore } from "./core/settings/useSettings.js";
-import { MainMenu } from "./view/main-menu.js";
-import { Editor } from "./view/editor.js";
-import { Settings } from "./view/settings.js";
+import { MainMenu } from "./view/page/main-menu.js";
+import { Editor } from "./view/page/editor.js";
+import { Settings } from "./view/page/settings.js";
 registerComponent(MainMenu, {});
 registerComponent(Editor, {}, { parent: MainMenu });
 registerComponent(Settings, {}, { parent: MainMenu });

package/dist/{view → utils/view}/click-mapping.d.ts

@@ -1,4 +1,4 @@
-import type { Document } from "../core/document/document.js";
+import type { Document } from "../../core/document/document.js";
 export type ClickTarget = {
     line: number;
     logical: number;

package/dist/{view → utils/view}/frame-clamp.d.ts

@@ -8,3 +8,7 @@ export declare function clampFrame(left: number, top: number, columns: number, r
     left: number;
     top: number;
 };
+export declare function clampBarPos(left: number, top: number, width: number, height: number, columns: number, rows: number, fileTreeOpen: boolean, treeWidth: number): {
+    left: number;
+    top: number;
+};

package/dist/{view → utils/view}/frame-clamp.js

@@ -10,3 +10,11 @@ export function clampFrame(left, top, columns, rows, width, height) {
         top: Math.min(Math.max(0, top), Math.max(0, rows - height)),
     };
 }
+export function clampBarPos(left, top, width, height, columns, rows, fileTreeOpen, treeWidth) {
+    const clamped = clampFrame(left, top, columns, rows, width, height);
+    const maxLeft = fileTreeOpen ? columns - treeWidth - width : columns - width;
+    return {
+        left: Math.min(Math.max(0, clamped.left), Math.max(0, maxLeft)),
+        top: Math.max(1, clamped.top),
+    };
+}

package/dist/{i18n-resources.js → utils/view/i18n-resources.js}

@@ -8,7 +8,7 @@ import { readFileSync } from "node:fs";
  * global installs work regardless of cwd — the JSON files ship inside the
  * package via the `asset` entry in `files`.
  */
-const LANGUAGE_DIR = new URL("../asset/language/", import.meta.url);
+const LANGUAGE_DIR = new URL("../../../asset/language/", import.meta.url);
 function loadPack(locale) {
     return JSON.parse(readFileSync(new URL(`${locale}.json`, LANGUAGE_DIR), "utf8"));
 }

package/dist/view/{command-bar.d.ts → editor/command-bar.d.ts}

@@ -1,5 +1,5 @@
 import React from "react";
-import type { EditorSession } from "../core/session.js";
+import type { EditorSession } from "../../core/io/session.js";
 export type CommandBarProps = {
     /** File session used by `:save`. */
     session?: EditorSession | null;

package/dist/view/{editor-setting.js → editor/editor-setting.js}

@@ -1,8 +1,8 @@
 import { Box, Text } from "ink";
 import { applyElement, back, closeLayer, LayerElementContext, openLayer, useI18n, useKeyboard, useMouseRegion, } from "ink-cartridge";
 import React, { useCallback, useContext, useEffect, useState } from "react";
-import { SettingsEntries } from "./settings.js";
-import { ModalFrame } from "./modal-frame.js";
+import { SettingsEntries } from "../page/settings.js";
+import { ModalFrame } from "../utils/modal-frame.js";
 /** Layer hosting the settings panel, opened on top of the menu layer. */
 const SETTINGS_PANEL_LAYER_ID = "settings-panel";
 const SETTINGS_PANEL_Z_INDEX = 3;

package/dist/view/{file-tree.d.ts → editor/file-tree.d.ts}

@@ -1,9 +1,13 @@
 import React from "react";
-import type { EditorSession } from "../core/session.js";
+import type { FileTreeState } from "../../core/io/file-tree-model.js";
+import type { EditorSession } from "../../core/io/session.js";
 export type FileTreeProps = {
     /** The shared file session; clicking a file opens it here. */
     session: EditorSession;
 };
+export type FileTreeDirState = FileTreeState | {
+    noDir?: boolean;
+};
 /**
  * VSCode-style file tree pinned to the right edge of the terminal (regular
  * layer element). Recursively scans the configured root directory once per