@tiagojct/subsub 0.20.0 → 0.21.0

package/dist/screens.js

@@ -0,0 +1,314 @@
+/**
+ * The notes and library screens of the terminal look, as pi-tui components for `ctx.ui.custom()`. Each has a pure function that draws it as
+ * lines (snapshots at 40, 80 and 120 columns) and a class that holds the state and the keys. The notes screen has two columns from 100 columns
+ * up (the list, and the note under the cursor); below that it is a list, and Enter opens a note.
+ */
+import { matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { cut, evidenceLine, fill, rule } from "./chrome.js";
+import { frontMatter, field } from "./notes.js";
+import { UNICODE } from "./skin.js";
+export const SCREEN_WORDS = {
+    en: {
+        notes: "Notes", of: "of", filter: "filter", none: "No notes yet. Sub-Sub writes them in Literature/, Research/ and Syntheses/.", noMatch: "No note matches.", empty: "(empty note)",
+        hintNotes: "up and down: choose   type: filter   PgUp PgDn: scroll   ctrl+o: open   Esc: close", hintRead: "up and down: scroll   ctrl+o: open   Esc: back",
+        library: "Library", typeToSearch: "Type to search your library.", searching: "Searching...", noItems: "Nothing found.", failed: "The search failed",
+        hintLibrary: "up and down: choose   Enter: read   ctrl+n: note   Esc: close", hintLibrarian: "up and down: choose   Enter: copy the key   Esc: close",
+    },
+    pt: {
+        notes: "Notas", of: "de", filter: "filtro", none: "Ainda não há notas. O Sub-Sub escreve-as em Literature/, Research/ e Syntheses/.", noMatch: "Nenhuma nota corresponde.", empty: "(nota vazia)",
+        hintNotes: "cima e baixo: escolher   escrever: filtrar   PgUp PgDn: deslocar   ctrl+o: abrir   Esc: fechar", hintRead: "cima e baixo: deslocar   ctrl+o: abrir   Esc: voltar",
+        library: "Biblioteca", typeToSearch: "Escreva para pesquisar na biblioteca.", searching: "A pesquisar...", noItems: "Nada encontrado.", failed: "A pesquisa falhou",
+        hintLibrary: "cima e baixo: escolher   Enter: ler   ctrl+n: nota   Esc: fechar", hintLibrarian: "cima e baixo: escolher   Enter: copiar a chave   Esc: fechar",
+    },
+};
+const LEFT = 36;
+const WIDE = 100;
+function pad(s, width) {
+    return s + " ".repeat(Math.max(0, width - visibleWidth(s)));
+}
+/** A key that types text (a letter, a digit, a pasted string), not a control or escape sequence. */
+export function printable(data) {
+    return data.length > 0 && !/[\x00-\x1f\x7f]/.test(data);
+}
+export function notesLines(o) {
+    const g = o.glyphs ?? UNICODE;
+    const p = o.paint;
+    const w = Math.max(20, o.width);
+    const words = SCREEN_WORDS[o.lang];
+    const rows = Math.max(3, o.rows - 5);
+    const wide = w >= WIDE && o.mode === "list";
+    const count = o.entries.length === o.total ? `${o.total}` : `${o.entries.length} ${words.of} ${o.total}`;
+    const out = [p.mark(cut(` ${words.notes}`, w)) + p.muted(cut(` (${count})${o.filter ? `   ${words.filter}: ${o.filter}` : ""}`, Math.max(0, w - words.notes.length - 1))), rule(w, "solid", p.muted, g)];
+    let bodyMax = 0;
+    const hint = (text) => wrapTextWithAnsi(` ${text}`, w).map((l) => p.muted(l));
+    if (o.total === 0 || o.entries.length === 0) {
+        out.push(p.muted(cut(`  ${o.total === 0 ? words.none : words.noMatch}`, w)), rule(w, "solid", p.muted, g), ...hint(words.hintNotes));
+        return { lines: out, bodyMax };
+    }
+    const list = (width) => {
+        const start = Math.max(0, Math.min(o.selected - Math.floor(rows / 2), o.entries.length - rows));
+        return o.entries.slice(start, start + rows).map((rel, k) => {
+            const chosen = start + k === o.selected;
+            return chosen ? `${p.mark(g.pointer)} ${p.text(cut(rel, width - 2))}` : `  ${p.muted(cut(rel, width - 2))}`;
+        });
+    };
+    const body = (width) => {
+        const lines = o.renderBody(Math.max(10, width));
+        const head = o.evidence ? [evidenceLine(o.evidence, o.lang, width, p, g), ""] : [];
+        const room = Math.max(1, rows - head.length);
+        bodyMax = Math.max(0, lines.length - room);
+        const from = Math.min(o.bodyScroll, bodyMax);
+        const shown = lines.slice(from, from + room).map((l) => truncateToWidth(l, width));
+        return [...head, ...(shown.length ? shown : [p.dim(words.empty)])];
+    };
+    if (wide) {
+        const right = w - LEFT - 3;
+        const left = list(LEFT);
+        const detail = body(right);
+        for (let i = 0; i < rows; i++)
+            out.push(`${pad(left[i] ?? "", LEFT)} ${p.muted(g.vertical)} ${detail[i] ?? ""}`);
+        out.push(rule(w, "solid", p.muted, g), ...hint(words.hintNotes));
+    }
+    else if (o.mode === "list") {
+        out.push(...list(w), rule(w, "solid", p.muted, g), ...hint(words.hintNotes));
+    }
+    else {
+        out.push(...body(w), rule(w, "solid", p.muted, g), ...hint(words.hintRead));
+    }
+    return { lines: out, bodyMax };
+}
+export class NotesView {
+    o;
+    filter = "";
+    selected = 0;
+    mode = "list";
+    bodyScroll = 0;
+    bodyMax = 0;
+    lastWidth = 80;
+    texts = new Map();
+    constructor(o) {
+        this.o = o;
+    }
+    entries() {
+        const f = this.filter.toLowerCase();
+        return f ? this.o.notes.filter((n) => n.rel.toLowerCase().includes(f)) : this.o.notes;
+    }
+    text() {
+        const n = this.entries()[this.selected];
+        if (!n)
+            return "";
+        let t = this.texts.get(n.path);
+        if (t === undefined) {
+            try {
+                t = this.o.read(n.path);
+            }
+            catch {
+                t = "";
+            }
+            this.texts.set(n.path, t);
+        }
+        return t;
+    }
+    render(width) {
+        this.lastWidth = width;
+        const text = this.text();
+        const front = frontMatter(text);
+        const evidence = front ? field(front, "evidence") : undefined;
+        const body = front ? text.slice(text.indexOf("\n---", 3) + 4).replace(/^\r?\n/, "") : text;
+        const entries = this.entries();
+        const view = notesLines({
+            width, rows: this.height(), lang: this.o.lang, paint: this.o.paint, glyphs: this.o.glyphs, mode: this.mode, entries: entries.map((n) => n.rel), total: this.o.notes.length,
+            selected: this.selected, filter: this.filter, evidence, renderBody: (w) => this.o.markdown(body, w), bodyScroll: this.bodyScroll,
+        });
+        this.bodyMax = view.bodyMax;
+        this.bodyScroll = Math.min(this.bodyScroll, this.bodyMax);
+        return fill(view.lines, width, this.height());
+    }
+    /** The screen covers the terminal, but for one line. */
+    height() {
+        return Math.max(8, (this.o.rows?.() ?? 24) - 1);
+    }
+    invalidate() { }
+    move(by) {
+        const n = this.entries().length;
+        if (!n)
+            return;
+        this.selected = Math.min(n - 1, Math.max(0, this.selected + by));
+        this.bodyScroll = 0;
+    }
+    handleInput(data) {
+        const page = Math.max(3, this.height() - 6);
+        const wideList = this.lastWidth >= WIDE && this.mode === "list";
+        const scrolls = this.mode === "read" || wideList;
+        if (matchesKey(data, "ctrl+c"))
+            return this.o.done();
+        if (matchesKey(data, "escape")) {
+            if (this.mode === "read")
+                this.mode = "list";
+            else if (this.filter) {
+                this.filter = "";
+                this.selected = 0;
+            }
+            else
+                return this.o.done();
+        }
+        else if (matchesKey(data, "ctrl+o")) {
+            const n = this.entries()[this.selected];
+            if (n)
+                this.o.open(n.path);
+            return;
+        }
+        else if (matchesKey(data, "enter")) {
+            if (this.mode === "list" && !wideList && this.entries().length) {
+                this.mode = "read";
+                this.bodyScroll = 0;
+            }
+        }
+        else if (matchesKey(data, "up")) {
+            if (this.mode === "read")
+                this.bodyScroll = Math.max(0, this.bodyScroll - 1);
+            else
+                this.move(-1);
+        }
+        else if (matchesKey(data, "down")) {
+            if (this.mode === "read")
+                this.bodyScroll = Math.min(this.bodyMax, this.bodyScroll + 1);
+            else
+                this.move(1);
+        }
+        else if (matchesKey(data, "pageUp")) {
+            if (scrolls)
+                this.bodyScroll = Math.max(0, this.bodyScroll - page);
+            else
+                this.move(-page);
+        }
+        else if (matchesKey(data, "pageDown")) {
+            if (scrolls)
+                this.bodyScroll = Math.min(this.bodyMax, this.bodyScroll + page);
+            else
+                this.move(page);
+        }
+        else if (this.mode === "list" && matchesKey(data, "backspace")) {
+            this.filter = this.filter.slice(0, -1);
+            this.selected = 0;
+        }
+        else if (this.mode === "list" && printable(data)) {
+            this.filter += data;
+            this.selected = 0;
+            this.bodyScroll = 0;
+        }
+        else
+            return;
+        this.o.redraw?.();
+    }
+}
+export function libraryLines(o) {
+    const g = o.glyphs ?? UNICODE;
+    const p = o.paint;
+    const w = Math.max(20, o.width);
+    const words = SCREEN_WORDS[o.lang];
+    const room = Math.max(2, o.rows - 5);
+    const out = [p.mark(cut(` ${words.library}`, w)), `${p.muted(" > ")}${p.text(cut(o.query, w - 4))}${p.mark("_")}`, rule(w, "solid", p.muted, g)];
+    if (o.state === "idle" && !o.query)
+        out.push(p.muted(cut(`  ${words.typeToSearch}`, w)));
+    else if (o.state === "searching")
+        out.push(p.muted(cut(`  ${words.searching}`, w)));
+    else if (o.state === "failed")
+        out.push(p.text(cut(`  ${g.hollow} ${words.failed}${o.error ? `: ${o.error.split("\n")[0]}` : ""}`, w)));
+    else if (!o.items.length)
+        out.push(p.muted(cut(`  ${words.noItems}`, w)));
+    else {
+        const per = 2;
+        const fit = Math.max(1, Math.floor(room / per));
+        const start = Math.max(0, Math.min(o.selected - Math.floor(fit / 2), o.items.length - fit));
+        for (const [k, it] of o.items.slice(start, start + fit).entries()) {
+            const chosen = start + k === o.selected;
+            const meta = [it.authors, it.year, it.citekey].filter(Boolean).join(" · ");
+            out.push(chosen ? `${p.mark(g.pointer)} ${p.text(cut(it.title || it.key, w - 2))}` : `  ${p.muted(cut(it.title || it.key, w - 2))}`, `  ${p.dim(cut(meta, w - 2))}`);
+        }
+    }
+    out.push(rule(w, "solid", p.muted, g), ...wrapTextWithAnsi(` ${o.researcher ? words.hintLibrary : words.hintLibrarian}`, w).map((l) => p.muted(l)));
+    return out;
+}
+export class LibraryView {
+    o;
+    query = "";
+    items = [];
+    selected = 0;
+    state = "idle";
+    error;
+    timer;
+    seq = 0;
+    constructor(o) {
+        this.o = o;
+    }
+    render(width) {
+        const height = Math.max(8, (this.o.rows?.() ?? 24) - 1);
+        return fill(libraryLines({
+            width, rows: height, lang: this.o.lang, paint: this.o.paint, glyphs: this.o.glyphs, researcher: this.o.researcher,
+            query: this.query, items: this.items, selected: this.selected, state: this.state, error: this.error,
+        }), width, height);
+    }
+    invalidate() { }
+    dispose() {
+        clearTimeout(this.timer);
+    }
+    schedule() {
+        clearTimeout(this.timer);
+        const q = this.query.replace(/\s+/g, " ").trim();
+        const mine = ++this.seq;
+        if (!q) {
+            this.items = [];
+            this.state = "idle";
+            return;
+        }
+        this.state = "searching";
+        this.timer = setTimeout(async () => {
+            try {
+                const items = await this.o.search(q);
+                if (mine !== this.seq)
+                    return; // a newer search is on its way
+                this.items = items;
+                this.state = "done";
+                this.selected = 0;
+            }
+            catch (err) {
+                if (mine !== this.seq)
+                    return;
+                this.state = "failed";
+                this.error = err.message;
+            }
+            this.o.redraw?.();
+        }, this.o.delay ?? 250);
+    }
+    handleInput(data) {
+        if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c"))
+            return this.o.done();
+        const item = this.items[this.selected];
+        if (matchesKey(data, "enter")) {
+            if (item)
+                this.o.choose(item);
+            return;
+        }
+        if (matchesKey(data, "ctrl+n")) {
+            if (item && this.o.researcher)
+                this.o.note(item);
+            return;
+        }
+        if (matchesKey(data, "up"))
+            this.selected = Math.max(0, this.selected - 1);
+        else if (matchesKey(data, "down"))
+            this.selected = Math.min(Math.max(0, this.items.length - 1), this.selected + 1);
+        else if (matchesKey(data, "backspace")) {
+            this.query = this.query.slice(0, -1);
+            this.schedule();
+        }
+        else if (printable(data)) {
+            this.query += data;
+            this.schedule();
+        }
+        else
+            return;
+        this.o.redraw?.();
+    }
+}

package/dist/skin.js

@@ -0,0 +1,37 @@
+/**
+ * The skin of the terminal screens: the paint roles drawn from a pi theme, and the glyphs. Meaning is never carried by
+ * colour alone: a rule is solid, dashed or dotted, a failure has a hollow mark and a word, and a terminal that cannot show
+ * the box-drawing glyphs (a non-UTF-8 locale, or SUBSUB_ASCII=1) gets plain ASCII.
+ */
+export const UNICODE = { solid: "─", dashed: "┄", dotted: "┈", hollow: "○", cell: "▰", cellEmpty: "▱", vertical: "│", pointer: "›" };
+export const ASCII = { solid: "=", dashed: "-", dotted: ".", hollow: "o", cell: "#", cellEmpty: "-", vertical: "|", pointer: ">" };
+/** ASCII when SUBSUB_ASCII is set, or when the locale is C, POSIX or names a character set that is not UTF-8 (pt_PT.ISO-8859-1). No locale, or one without a character set, means UTF-8. */
+export function useAscii(env = process.env) {
+    if (env.SUBSUB_ASCII && env.SUBSUB_ASCII !== "0")
+        return true;
+    const locale = env.LC_ALL || env.LC_CTYPE || env.LANG;
+    if (!locale || /utf-?8/i.test(locale))
+        return false;
+    return locale === "C" || locale === "POSIX" || /\.[^.]+$/.test(locale);
+}
+export function glyphs(env = process.env) {
+    return useAscii(env) ? ASCII : UNICODE;
+}
+/** Paint roles from the colours of a pi theme (themes/*.json): accent, text, muted, dim, success (sap) and warning (gamboge). */
+export function paintFromTheme(th) {
+    return {
+        mark: (x) => th.fg("accent", x),
+        text: (x) => th.fg("text", x),
+        muted: (x) => th.fg("muted", x),
+        dim: (x) => th.fg("dim", x),
+        ok: (x) => th.fg("success", x),
+        pend: (x) => th.fg("warning", x),
+        // A removal has no colour of its own: muted ink, struck through, and the "-" in front stays for terminals that ignore the strike.
+        strike: (x) => (th.strikethrough ? th.strikethrough(th.fg("muted", x)) : th.fg("muted", x)),
+    };
+}
+/** Frames of the working indicator: dotted, dashed, solid, dashed. One static frame when motion is reduced (SUBSUB_REDUCE_MOTION=1). */
+export function workingFrames(g, reduceMotion = false) {
+    const dashed = g.dashed.repeat(4);
+    return reduceMotion ? [dashed] : [g.dotted.repeat(4), dashed, g.solid.repeat(4), dashed];
+}