@lapis-notes/csv 0.0.0-stage → 0.2.0

package/dist/lib/csv-plugin.js

@@ -0,0 +1,107 @@
+import { Plugin, } from "@lapis-notes/api";
+import { mount, unmount } from "svelte";
+import manifestSpec from "../../manifest.json";
+import CsvSheet from "./CsvSheet.svelte";
+import CsvTable from "./CsvTable.svelte";
+import { CSV_EXTENSIONS, CSV_FILENAME_PATTERNS, CSV_PLUGIN_ID, CSV_VIEW_TYPE, } from "./ids";
+import { csvSourceExtensions } from "./codemirror/csv-source-extensions";
+import { readDefaultCsvView, registerCsvViewSettings } from "./csv-view-settings";
+import { CsvFileView } from "./views/csv-view";
+export { CSV_PLUGIN_ID, CSV_VIEW_TYPE, CSV_FILENAME_PATTERNS };
+const tableExtensions = new Set(CSV_EXTENSIONS);
+function isTableFile(file) {
+    return tableExtensions.has(file?.extension.toLowerCase() ?? "");
+}
+function mountEmbed(app, containerEl, file) {
+    containerEl.style.display = "flex";
+    containerEl.style.flexDirection = "column";
+    containerEl.style.width = "100%";
+    containerEl.style.height = "auto";
+    containerEl.style.minHeight = "0";
+    containerEl.style.overflow = "auto";
+    const presentation = readDefaultCsvView(app);
+    const component = presentation === "canvas"
+        ? mount(CsvSheet, {
+            target: containerEl,
+            props: { app, file, role: "embed" },
+        })
+        : mount(CsvTable, {
+            target: containerEl,
+            props: { app, file, role: "embed" },
+        });
+    return {
+        destroy: () => {
+            void unmount(component);
+        },
+    };
+}
+export class CSVPlugin extends Plugin {
+    constructor(app, manifest = manifestSpec) {
+        super(app, manifest);
+    }
+    onload() {
+        this.registerView(CSV_VIEW_TYPE, (leaf) => new CsvFileView(leaf), {
+            kind: "file",
+        });
+        this.registerEditorView({
+            id: `${CSV_VIEW_TYPE}-file`,
+            viewType: CSV_VIEW_TYPE,
+            label: "CSV",
+            filenamePatterns: [...CSV_FILENAME_PATTERNS],
+            priority: "exclusive",
+        });
+        this.registerExtensions([...CSV_EXTENSIONS], CSV_VIEW_TYPE);
+        this.registerEditorExtension(() => csvSourceExtensions(this.app), CSV_VIEW_TYPE);
+        for (const extension of CSV_EXTENSIONS) {
+            this.register(this.app.embedRegistry.register(extension, ({ app, containerEl, state }) => {
+                const file = state.file;
+                if (!isTableFile(file) || file.extension.toLowerCase() !== extension)
+                    return;
+                return mountEmbed(app, containerEl, file);
+            }));
+        }
+        this.addCommand({
+            id: "open-csv",
+            name: "Open CSV",
+            icon: "lucide-table",
+            callback: () => this.openTable(this.app.workspace.activeLeaf),
+        });
+        this.addCommand({
+            id: "toggle-csv-source",
+            name: "Toggle CSV source",
+            icon: "lucide-file-code",
+            checkCallback: (checking) => {
+                const view = this.app.workspace.activeLeaf?.view;
+                if (!(view instanceof CsvFileView))
+                    return false;
+                if (!checking)
+                    view.toggleMode();
+                return true;
+            },
+        });
+        this.addCommand({
+            id: "show-csv-canvas",
+            name: "Show CSV canvas",
+            icon: "lucide-grid-3x3",
+            checkCallback: (checking) => {
+                const view = this.app.workspace.activeLeaf?.view;
+                if (!(view instanceof CsvFileView))
+                    return false;
+                if (!checking)
+                    view.showCanvas();
+                return true;
+            },
+        });
+        registerCsvViewSettings(this);
+    }
+    openTable(leaf) {
+        const file = this.app.workspace.getActiveFile();
+        if (!isTableFile(file) || !leaf)
+            return;
+        void leaf.setViewState({
+            type: CSV_VIEW_TYPE,
+            state: { file: file.path },
+        });
+    }
+}
+export default CSVPlugin;

package/dist/lib/csv-view-settings.d.ts

@@ -0,0 +1,43 @@
+import type { App, Plugin } from "@lapis-notes/api";
+export type CsvTablePresentation = "table" | "canvas";
+export declare const CSV_SETTINGS_SECTION_ID = "lapis-csv";
+export declare const CSV_SETTING_IDS: {
+    readonly defaultView: "lapis-csv.defaultView";
+};
+export declare const CSV_CONFIGURATION_SCHEMA: {
+    id: string;
+    title: string;
+    type: "object";
+    properties: {
+        "lapis-csv.defaultView": {
+            title: string;
+            description: string;
+            type: "string";
+            default: string;
+            enum: string[];
+        };
+    };
+};
+export declare function isCsvTablePresentation(value: unknown): value is CsvTablePresentation;
+export declare function readDefaultCsvView(app: App): CsvTablePresentation;
+export declare function createCsvSettingsSection(): {
+    id: string;
+    title: string;
+    description: string;
+    icon: "table";
+    order: number;
+    navigationGroupId: string;
+    sourcePluginId: string;
+    fields: {
+        id: "lapis-csv.defaultView";
+        title: string;
+        description: string;
+        type: "enum";
+        default: "canvas";
+        options: {
+            value: string;
+            label: string;
+        }[];
+    }[];
+};
+export declare function registerCsvViewSettings(plugin: Plugin): void;

package/dist/lib/csv-view-settings.js

@@ -0,0 +1,86 @@
+import { getWorkspaceHostBinding } from "@lapis-notes/api/workspace-host";
+import { CSV_PLUGIN_ID } from "./ids";
+export const CSV_SETTINGS_SECTION_ID = "lapis-csv";
+export const CSV_SETTING_IDS = {
+    defaultView: "lapis-csv.defaultView",
+};
+const DEFAULT_VIEW_FIELD = {
+    title: "Default table view",
+    description: "Open a CSV or TSV as the table or the canvas sheet.",
+    type: "string",
+    default: "canvas",
+    enum: ["table", "canvas"],
+};
+export const CSV_CONFIGURATION_SCHEMA = {
+    id: "lapis-csv",
+    title: "CSV",
+    type: "object",
+    properties: {
+        [CSV_SETTING_IDS.defaultView]: DEFAULT_VIEW_FIELD,
+    },
+};
+function settingsController(app) {
+    try {
+        return getWorkspaceHostBinding(app.workspace).controller
+            .settings;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function isCsvTablePresentation(value) {
+    return value === "table" || value === "canvas";
+}
+export function readDefaultCsvView(app) {
+    const live = settingsController(app)?.get(CSV_SETTING_IDS.defaultView);
+    if (isCsvTablePresentation(live))
+        return live;
+    const stored = app.configuration
+        ?.getConfiguration()
+        .get(CSV_SETTING_IDS.defaultView, "canvas");
+    return isCsvTablePresentation(stored) ? stored : "canvas";
+}
+export function createCsvSettingsSection() {
+    return {
+        id: CSV_SETTINGS_SECTION_ID,
+        title: "CSV",
+        description: "How CSV and TSV files open.",
+        icon: "table",
+        order: 29,
+        navigationGroupId: "core-plugins",
+        sourcePluginId: CSV_PLUGIN_ID,
+        fields: [
+            {
+                id: CSV_SETTING_IDS.defaultView,
+                title: DEFAULT_VIEW_FIELD.title,
+                description: DEFAULT_VIEW_FIELD.description,
+                type: "enum",
+                default: "canvas",
+                options: [
+                    { value: "table", label: "Table" },
+                    { value: "canvas", label: "Canvas" },
+                ],
+            },
+        ],
+    };
+}
+export function registerCsvViewSettings(plugin) {
+    const schema = plugin.app.configuration?.schema;
+    if (schema) {
+        schema.register(CSV_CONFIGURATION_SCHEMA);
+        plugin.register(() => {
+            schema.unregister(CSV_CONFIGURATION_SCHEMA);
+        });
+        void plugin.app.configuration?.materializeSchemaDefaults?.();
+    }
+    const settings = settingsController(plugin.app);
+    if (!settings)
+        return;
+    try {
+        const dispose = getWorkspaceHostBinding(plugin.app.workspace).controller.registerSettingsSection(createCsvSettingsSection());
+        plugin.register(dispose);
+    }
+    catch {
+        return;
+    }
+}

package/dist/lib/ids.d.ts

@@ -0,0 +1,8 @@
+export declare const CSV_PLUGIN_ID = "lapis-csv";
+export declare const CSV_VIEW_TYPE = "lapis-csv";
+export declare const CSV_EXTENSIONS: readonly ["csv", "tsv"];
+export declare const CSV_FILENAME_PATTERNS: readonly ["*.csv", "*.tsv"];
+export declare const SAMPLE_CSV_PATH = "Sample.csv";
+export declare const SAMPLE_READING_NOTE_PATH = "Notes/Staff readings.md";
+export declare const SAMPLE_PLAIN_NOTE_PATH = "Notes/Welcome.md";
+export declare function sampleReadingMarkdown(): string;

package/dist/lib/ids.js

@@ -0,0 +1,19 @@
+export const CSV_PLUGIN_ID = "lapis-csv";
+export const CSV_VIEW_TYPE = "lapis-csv";
+export const CSV_EXTENSIONS = ["csv", "tsv"];
+export const CSV_FILENAME_PATTERNS = ["*.csv", "*.tsv"];
+export const SAMPLE_CSV_PATH = "Sample.csv";
+export const SAMPLE_READING_NOTE_PATH = "Notes/Staff readings.md";
+export const SAMPLE_PLAIN_NOTE_PATH = "Notes/Welcome.md";
+export function sampleReadingMarkdown() {
+    return [
+        "# Staff readings",
+        "",
+        "The south basin kept the late tide.",
+        "",
+        "![[Sample.csv]]",
+        "",
+        "![[Welcome.md]]",
+        "",
+    ].join("\n");
+}

package/dist/lib/model/csv-column-sort.d.ts

@@ -0,0 +1,16 @@
+import type { CsvGrid } from "./csv-grid";
+export type CsvColumnSortDirection = "asc" | "desc";
+export type CsvColumnSort = {
+    index: number;
+    direction: CsvColumnSortDirection;
+    baseline: string[][];
+    /** Baseline index for each current visual row. */
+    order: number[];
+};
+export declare function nextCsvColumnSortDirection(state: CsvColumnSort | null, index: number): CsvColumnSortDirection | "clear";
+export declare function applyCsvColumnSort(grid: CsvGrid, state: CsvColumnSort | null, index: number, direction: CsvColumnSortDirection | "clear", headerRow: boolean): CsvColumnSort | null;
+export declare function toggleCsvColumnSort(grid: CsvGrid, state: CsvColumnSort | null, index: number, headerRow: boolean): CsvColumnSort | null;
+export declare function noteCsvColumnSortEdit(state: CsvColumnSort, row: number, col: number, value: string): void;
+export declare function noteCsvColumnInserted(state: CsvColumnSort | null, index: number): CsvColumnSort | null;
+export declare function noteCsvColumnDeleted(state: CsvColumnSort | null, index: number): CsvColumnSort | null;
+export declare function noteCsvColumnMoved(state: CsvColumnSort | null, from: number, to: number): CsvColumnSort | null;

package/dist/lib/model/csv-column-sort.js

@@ -0,0 +1,81 @@
+export function nextCsvColumnSortDirection(state, index) {
+    if (!state || state.index !== index)
+        return "asc";
+    if (state.direction === "asc")
+        return "desc";
+    return "clear";
+}
+export function applyCsvColumnSort(grid, state, index, direction, headerRow) {
+    if (direction === "clear") {
+        if (state)
+            grid.replaceRows(state.baseline);
+        return null;
+    }
+    const baseline = state?.baseline ?? grid.getRows();
+    if (state)
+        grid.replaceRows(baseline);
+    const permutation = grid.sortColumn(index, direction === "asc", headerRow ? 1 : 0);
+    return { index, direction, baseline, order: permutation };
+}
+export function toggleCsvColumnSort(grid, state, index, headerRow) {
+    return applyCsvColumnSort(grid, state, index, nextCsvColumnSortDirection(state, index), headerRow);
+}
+export function noteCsvColumnSortEdit(state, row, col, value) {
+    const source = state.order[row];
+    const line = source == null ? undefined : state.baseline[source];
+    if (!line)
+        return;
+    while (line.length <= col)
+        line.push("");
+    line[col] = value;
+}
+export function noteCsvColumnInserted(state, index) {
+    if (!state)
+        return null;
+    return {
+        ...state,
+        baseline: state.baseline.map((row) => {
+            const next = [...row];
+            next.splice(index, 0, "");
+            return next;
+        }),
+        index: state.index >= index ? state.index + 1 : state.index,
+    };
+}
+export function noteCsvColumnDeleted(state, index) {
+    if (!state || state.index === index)
+        return null;
+    return {
+        ...state,
+        baseline: state.baseline.map((row) => {
+            const next = [...row];
+            if (index >= 0 && index < next.length)
+                next.splice(index, 1);
+            return next;
+        }),
+        index: state.index > index ? state.index - 1 : state.index,
+    };
+}
+export function noteCsvColumnMoved(state, from, to) {
+    if (!state || from === to)
+        return state;
+    return {
+        ...state,
+        baseline: state.baseline.map((row) => {
+            const next = [...row];
+            const [cell] = next.splice(from, 1);
+            next.splice(to, 0, cell ?? "");
+            return next;
+        }),
+        index: movedColumnIndex(state.index, from, to),
+    };
+}
+function movedColumnIndex(current, from, to) {
+    if (current === from)
+        return to;
+    if (from < current && to >= current)
+        return current - 1;
+    if (from > current && to <= current)
+        return current + 1;
+    return current;
+}

package/dist/lib/model/csv-grid.d.ts

@@ -0,0 +1,31 @@
+import type { CsvDelimiter } from "../../csv-settings";
+export type CsvGridOptions = {
+    delimiter: CsvDelimiter;
+    headerRow: boolean;
+};
+export declare class CsvGrid {
+    private rows;
+    private constructor();
+    static fromText(text: string, options: CsvGridOptions): CsvGrid;
+    static empty(): CsvGrid;
+    clone(): CsvGrid;
+    getRowCount(): number;
+    getColCount(): number;
+    getRows(): string[][];
+    getCell(row: number, col: number): string;
+    updateCell(row: number, col: number, value: string): void;
+    insertRowAt(index: number): void;
+    deleteRowAt(index: number): void;
+    insertColumnAt(index: number): void;
+    deleteColumnAt(index: number): void;
+    moveColumnAt(from: number, to: number): void;
+    moveRowAt(from: number, to: number): void;
+    clearCellsAt(coords: Array<[row: number, col: number]>): void;
+    ensureHeaderRow(initialLabels?: string[]): void;
+    replaceRows(rows: readonly string[][]): void;
+    /** Reorders body rows and returns the previous index now occupying each row. */
+    sortColumn(index: number, ascending: boolean, startRow?: number): number[];
+    toText(options: Pick<CsvGridOptions, "delimiter">): string;
+    private ensureSize;
+    private trimTrailingEmpty;
+}

package/dist/lib/model/csv-grid.js

@@ -0,0 +1,161 @@
+import { parseCsvText } from "./parse-csv";
+import { serializeCsvRows } from "./serialize-csv";
+export class CsvGrid {
+    rows;
+    constructor(rows) {
+        this.rows = rows.map((row) => [...row]);
+    }
+    static fromText(text, options) {
+        const { rows } = parseCsvText(text, { delimiter: options.delimiter });
+        const normalized = rows.length ? rows : [[""]];
+        return new CsvGrid(normalized);
+    }
+    static empty() {
+        return new CsvGrid([[""]]);
+    }
+    clone() {
+        return new CsvGrid(this.rows);
+    }
+    getRowCount() {
+        return this.rows.length;
+    }
+    getColCount() {
+        return this.rows.reduce((max, row) => Math.max(max, row.length), 0);
+    }
+    getRows() {
+        return this.rows.map((row) => [...row]);
+    }
+    getCell(row, col) {
+        return this.rows[row]?.[col] ?? "";
+    }
+    updateCell(row, col, value) {
+        this.ensureSize(row + 1, col + 1);
+        this.rows[row][col] = value;
+        this.trimTrailingEmpty();
+    }
+    insertRowAt(index) {
+        const width = this.getColCount();
+        const row = Array.from({ length: Math.max(width, 1) }, () => "");
+        const clamped = Math.max(0, Math.min(index, this.rows.length));
+        this.rows.splice(clamped, 0, row);
+    }
+    deleteRowAt(index) {
+        if (this.rows.length <= 1) {
+            this.rows = [[""]];
+            return;
+        }
+        if (index >= 0 && index < this.rows.length) {
+            this.rows.splice(index, 1);
+        }
+    }
+    insertColumnAt(index) {
+        const clamped = Math.max(0, Math.min(index, this.getColCount()));
+        for (const row of this.rows) {
+            row.splice(clamped, 0, "");
+        }
+        if (this.rows.length === 0) {
+            this.rows.push([""]);
+        }
+    }
+    deleteColumnAt(index) {
+        const width = this.getColCount();
+        if (width <= 1) {
+            this.rows = this.rows.map(() => [""]);
+            return;
+        }
+        for (const row of this.rows) {
+            if (index >= 0 && index < row.length) {
+                row.splice(index, 1);
+            }
+        }
+    }
+    moveColumnAt(from, to) {
+        if (from === to || from < 0 || to < 0) {
+            return;
+        }
+        const width = this.getColCount();
+        if (from >= width || to >= width) {
+            return;
+        }
+        for (const row of this.rows) {
+            const [cell] = row.splice(from, 1);
+            row.splice(to, 0, cell);
+        }
+    }
+    moveRowAt(from, to) {
+        if (from === to || from < 0 || to < 0) {
+            return;
+        }
+        if (from >= this.rows.length || to >= this.rows.length) {
+            return;
+        }
+        const [row] = this.rows.splice(from, 1);
+        this.rows.splice(to, 0, row);
+    }
+    clearCellsAt(coords) {
+        for (const [row, col] of coords) {
+            if (row >= 0 && col >= 0 && row < this.rows.length) {
+                if (col < this.rows[row].length) {
+                    this.rows[row][col] = "";
+                }
+            }
+        }
+        this.trimTrailingEmpty();
+    }
+    ensureHeaderRow(initialLabels) {
+        if (this.rows.length === 0) {
+            const width = Math.max(this.getColCount(), initialLabels?.length ?? 1);
+            this.rows.push(Array.from({ length: width }, (_, column) => initialLabels?.[column] ?? ""));
+            return;
+        }
+        const width = this.getColCount();
+        this.rows.unshift(Array.from({ length: width }, (_, column) => initialLabels?.[column] ?? ""));
+    }
+    replaceRows(rows) {
+        this.rows = rows.map((row) => [...row]);
+    }
+    /** Reorders body rows and returns the previous index now occupying each row. */
+    sortColumn(index, ascending, startRow = 0) {
+        const current = this.rows;
+        const order = current.map((_, rowIndex) => rowIndex);
+        const body = order.slice(startRow);
+        body.sort((left, right) => {
+            const a = current[left]?.[index] ?? "";
+            const b = current[right]?.[index] ?? "";
+            const cmp = a.localeCompare(b, undefined, {
+                numeric: true,
+                sensitivity: "base",
+            });
+            return ascending ? cmp : -cmp;
+        });
+        const next = [...order.slice(0, startRow), ...body];
+        this.rows = next.map((rowIndex) => [...(current[rowIndex] ?? [])]);
+        return next;
+    }
+    toText(options) {
+        const rows = this.getRows();
+        if (rows.length === 0) {
+            return "";
+        }
+        return serializeCsvRows(rows, { delimiter: options.delimiter });
+    }
+    ensureSize(rowCount, colCount) {
+        while (this.rows.length < rowCount) {
+            this.rows.push(Array.from({ length: colCount }, () => ""));
+        }
+        for (const row of this.rows) {
+            while (row.length < colCount) {
+                row.push("");
+            }
+        }
+    }
+    trimTrailingEmpty() {
+        while (this.rows.length > 1) {
+            const last = this.rows[this.rows.length - 1];
+            if (last.some((cell) => cell.trim().length > 0)) {
+                break;
+            }
+            this.rows.pop();
+        }
+    }
+}

package/dist/lib/model/csv-search.d.ts

@@ -0,0 +1,38 @@
+import { SearchQuery } from "@codemirror/search";
+import { type Text } from "@codemirror/state";
+export type CsvCellMatch = {
+    row: number;
+    col: number;
+    from: number;
+    to: number;
+};
+export type CsvSearchOptions = {
+    search: string;
+    replace?: string;
+    caseSensitive?: boolean;
+    wholeWord?: boolean;
+    regexp?: boolean;
+};
+export declare function csvSearchQuery(options: CsvSearchOptions): SearchQuery;
+/** Matches in row-major order. An empty or invalid query matches nothing. */
+export declare function csvCellMatches(rows: readonly (readonly string[])[], query: SearchQuery): CsvCellMatch[];
+export declare function csvDocumentMatches(doc: Text, query: SearchQuery): Array<{
+    from: number;
+    to: number;
+}>;
+/** Replacement text for one match, including regular-expression substitutions. */
+export declare function searchReplacement(query: SearchQuery, matched: string): string;
+export declare function replaceCellText(cell: string, ranges: readonly {
+    from: number;
+    to: number;
+}[], query: SearchQuery): string;
+export declare function csvBodyCounts(rowCount: number, colCount: number, headerRow: boolean): {
+    columns: number;
+    rows: number;
+};
+/** Data rows that contain a match. Header matches do not count. */
+export declare function csvShownRowCount(rowCount: number, headerRow: boolean, matches: readonly {
+    row: number;
+}[]): number;
+export declare function csvStatusLabel(columns: number, rows: number, shownRows?: number): string;
+export declare function isCsvFindShortcut(event: KeyboardEvent): boolean;