@lapis-notes/lapis-plugin-docs 0.0.0-stage → 0.2.0

package/dist/docs-index.d.ts

@@ -0,0 +1,5 @@
+import type { IndexFieldDefinition, IndexProjectionRegistration } from "@lapis-notes/api/app-database";
+export declare const DOCS_NOTE_PROJECTION_ID = "note";
+export declare const DOCS_NOTE_PROJECTION_VERSION = 1;
+export declare const DOCS_NOTE_PROJECTION_FIELDS: Record<string, IndexFieldDefinition>;
+export declare function createDocsProjectionRegistration(docsRoot: string): IndexProjectionRegistration;

package/dist/docs-index.js

@@ -0,0 +1,49 @@
+import { parseDocsNoteMarkdownFile } from "./model";
+import { normalizeDocsRoot } from "./docs-settings";
+export const DOCS_NOTE_PROJECTION_ID = "note";
+export const DOCS_NOTE_PROJECTION_VERSION = 1;
+export const DOCS_NOTE_PROJECTION_FIELDS = {
+    id: { type: "string", indexed: true },
+    title: { type: "string", indexed: true },
+    docType: { type: "string", indexed: true },
+    path: { type: "path", indexed: true },
+    tags: { type: "string", indexed: true, cardinality: "many" },
+    cardCount: { type: "number", indexed: false },
+    bookId: { type: "string", indexed: true },
+};
+export function createDocsProjectionRegistration(docsRoot) {
+    const root = normalizeDocsRoot(docsRoot);
+    return {
+        id: DOCS_NOTE_PROJECTION_ID,
+        version: DOCS_NOTE_PROJECTION_VERSION,
+        visibility: "public",
+        fields: DOCS_NOTE_PROJECTION_FIELDS,
+        source: {
+            extensions: ["doc.md"],
+            pathPrefix: root,
+        },
+        project({ file, content }) {
+            const note = parseDocsNoteMarkdownFile({ path: file.path, content });
+            if (!note)
+                return { rows: [], edges: [] };
+            return {
+                rows: [
+                    {
+                        id: note.id,
+                        kind: "note",
+                        data: {
+                            id: note.id,
+                            title: note.title,
+                            docType: note.docType,
+                            path: note.sourcePath,
+                            tags: note.tags,
+                            cardCount: note.cards.length,
+                            bookId: note.bookId ?? "",
+                        },
+                    },
+                ],
+                edges: [],
+            };
+        },
+    };
+}

package/dist/docs-path.d.ts

@@ -0,0 +1,6 @@
+export declare const DOCS_DOCUMENT_VIEW_TYPE = "docs-document";
+export declare const DOCS_FILENAME_PATTERNS: readonly ["*.doc.md"];
+export declare const DOCS_EXTENSIONS: readonly ["doc.md"];
+export declare const DOCS_FILE_GLOB = "**/*.doc.md";
+export declare function isDocsDocumentPath(path: string): boolean;
+export declare function docsDocumentExtension(path: string): string;

package/dist/docs-path.js

@@ -0,0 +1,10 @@
+export const DOCS_DOCUMENT_VIEW_TYPE = "docs-document";
+export const DOCS_FILENAME_PATTERNS = ["*.doc.md"];
+export const DOCS_EXTENSIONS = ["doc.md"];
+export const DOCS_FILE_GLOB = "**/*.doc.md";
+export function isDocsDocumentPath(path) {
+    return /\.doc\.md$/i.test(path.replaceAll("\\", "/"));
+}
+export function docsDocumentExtension(path) {
+    return isDocsDocumentPath(path) ? "doc.md" : "";
+}

package/dist/docs-plugin.d.ts

@@ -0,0 +1,21 @@
+import { Plugin, type App, type PluginManifest } from "@lapis-notes/api";
+import { DocsRepository } from "./docs-repository";
+import { type DocsPluginSettings, type DocsPluginSettingsPatch } from "./docs-settings";
+export declare const DOCS_PLUGIN_ID = "docs";
+export declare class DocsPlugin extends Plugin {
+    readonly repository: DocsRepository;
+    clock: () => Date;
+    private data;
+    private saveQueue;
+    private readonly settingsListeners;
+    constructor(app: App, pluginManifest?: PluginManifest);
+    onload(): Promise<void>;
+    getSettings(): DocsPluginSettings;
+    updateSettings(patch: DocsPluginSettingsPatch): Promise<void>;
+    subscribeSettings(listener: (settings: DocsPluginSettings) => void): () => void;
+    openDocs(): Promise<void>;
+    openCards(): Promise<void>;
+    openReview(scope: "note" | "workspace"): Promise<void>;
+    private focusDocumentPanel;
+}
+export default DocsPlugin;

package/dist/docs-plugin.js

@@ -0,0 +1,140 @@
+import { Plugin, } from "@lapis-notes/api";
+import { requestDocsDocumentSurface } from "./docs/docs-document-surface";
+import { createDocsProjectionRegistration } from "./docs-index";
+import { DocsDocumentView } from "./docs-document-view";
+import { DOCS_DOCUMENT_VIEW_TYPE, DOCS_EXTENSIONS, DOCS_FILENAME_PATTERNS, isDocsDocumentPath, } from "./docs-path";
+import { DocsRepository, createVaultDocsFileStore } from "./docs-repository";
+import { cloneDocsPluginSettings, migrateDocsPluginData, patchDocsPluginSettings, } from "./docs-settings";
+import { DocsSettingsTab } from "./docs-settings-tab";
+import { DOCS_CARDS_VIEW_TYPE, DocsCardsView } from "./docs-cards-view";
+import { DOCS_REVIEW_VIEW_TYPE, DocsReviewView } from "./docs-review-view";
+import { DOCS_VIEW_TYPE, DocsView } from "./docs-view";
+export const DOCS_PLUGIN_ID = "docs";
+const MANIFEST = {
+    id: DOCS_PLUGIN_ID,
+    name: "Docs",
+    version: "0.1.0",
+    minAppVersion: "0.0.1",
+    description: "Vault-native Docs notes, books, cards, and FSRS review.",
+    author: "Lapis Notes",
+};
+export class DocsPlugin extends Plugin {
+    repository;
+    clock = () => new Date();
+    data = migrateDocsPluginData(null);
+    saveQueue = Promise.resolve();
+    settingsListeners = new Set();
+    constructor(app, pluginManifest = MANIFEST) {
+        super(app, pluginManifest);
+        this.repository = new DocsRepository(createVaultDocsFileStore(app));
+    }
+    async onload() {
+        this.data = migrateDocsPluginData(await this.loadData());
+        this.registerIndexProjection(createDocsProjectionRegistration(this.getSettings().docsRoot));
+        this.registerSidebarView(DOCS_VIEW_TYPE, (leaf) => new DocsView(leaf, this.repository, () => this.clock(), {
+            get: () => this.getSettings(),
+            subscribe: (listener) => this.subscribeSettings(listener),
+        }), { side: "left", title: "Docs", icon: "book-open" });
+        this.registerView(DOCS_DOCUMENT_VIEW_TYPE, (leaf) => new DocsDocumentView(leaf, this.repository, () => this.clock()));
+        this.registerView(DOCS_CARDS_VIEW_TYPE, (leaf) => new DocsCardsView(leaf, this.repository, () => this.clock(), {
+            get: () => this.getSettings(),
+            subscribe: (listener) => this.subscribeSettings(listener),
+        }));
+        this.registerView(DOCS_REVIEW_VIEW_TYPE, (leaf) => new DocsReviewView(leaf, this.repository, () => this.clock(), {
+            get: () => this.getSettings(),
+            subscribe: (listener) => this.subscribeSettings(listener),
+        }));
+        this.registerEditorView({
+            id: DOCS_DOCUMENT_VIEW_TYPE,
+            viewType: DOCS_DOCUMENT_VIEW_TYPE,
+            label: "Docs",
+            filenamePatterns: [...DOCS_FILENAME_PATTERNS],
+            priority: "exclusive",
+        });
+        this.registerExtensions([...DOCS_EXTENSIONS], DOCS_DOCUMENT_VIEW_TYPE);
+        this.addCommand({
+            id: "open",
+            name: "Open docs",
+            callback: () => void this.openDocs(),
+        });
+        this.addCommand({
+            id: "open-cards",
+            name: "Open cards",
+            callback: () => void this.openCards(),
+        });
+        this.addCommand({
+            id: "review-note",
+            name: "Review due cards (note)",
+            callback: () => void this.openReview("note"),
+        });
+        this.addCommand({
+            id: "review-workspace",
+            name: "Review due cards (workspace)",
+            callback: () => void this.openReview("workspace"),
+        });
+        this.addRibbonIcon("book-open", "Open Docs", () => void this.openDocs());
+        this.addSettingTab(new DocsSettingsTab(this.app, this));
+    }
+    getSettings() {
+        return cloneDocsPluginSettings(this.data.settings);
+    }
+    async updateSettings(patch) {
+        this.data = {
+            ...this.data,
+            settings: patchDocsPluginSettings(this.data.settings, patch),
+        };
+        const snapshot = {
+            version: this.data.version,
+            settings: this.getSettings(),
+        };
+        this.saveQueue = this.saveQueue
+            .catch(() => undefined)
+            .then(() => this.saveData(snapshot));
+        await this.saveQueue;
+        for (const listener of this.settingsListeners) {
+            listener(cloneDocsPluginSettings(snapshot.settings));
+        }
+    }
+    subscribeSettings(listener) {
+        this.settingsListeners.add(listener);
+        return () => this.settingsListeners.delete(listener);
+    }
+    async openDocs() {
+        const existing = this.app.workspace.getLeavesOfType(DOCS_VIEW_TYPE)[0];
+        const leaf = existing ?? this.app.workspace.ensureSideLeaf(DOCS_VIEW_TYPE, "left");
+        if (leaf.view.getViewType() !== DOCS_VIEW_TYPE) {
+            await leaf.setViewState({ type: DOCS_VIEW_TYPE, active: true });
+        }
+        this.app.workspace.activateLeaf(leaf, {
+            focusRootHost: false,
+            source: "api",
+            operation: "open-docs",
+        });
+        await this.app.workspace.revealLeaf(leaf);
+    }
+    async openCards() {
+        await this.focusDocumentPanel("cards");
+    }
+    async openReview(scope) {
+        await this.focusDocumentPanel("review", scope);
+    }
+    async focusDocumentPanel(panel, reviewScope) {
+        const file = this.app.workspace.getActiveFile();
+        const documentLeaf = this.app.workspace
+            .getLeavesOfType(DOCS_DOCUMENT_VIEW_TYPE)
+            .find((leaf) => leaf.view instanceof DocsDocumentView && leaf.view.file);
+        const path = file && isDocsDocumentPath(file.path)
+            ? file.path
+            : documentLeaf?.view instanceof DocsDocumentView
+                ? documentLeaf.view.file?.path
+                : undefined;
+        if (!path)
+            return;
+        requestDocsDocumentSurface(path, {
+            panel,
+            ...(reviewScope ? { reviewScope } : {}),
+        });
+        await this.app.workspace.openLinkText(path, "", false);
+    }
+}
+export default DocsPlugin;

package/dist/docs-repository.d.ts

@@ -0,0 +1,15 @@
+import type { App } from "@lapis-notes/api";
+import { type DocsNote } from "./model";
+export type DocsFileStore = {
+    read(path: string): Promise<string>;
+    write(path: string, content: string): Promise<void>;
+    listMarkdown(root: string): Promise<string[]>;
+};
+export declare function createVaultDocsFileStore(app: App): DocsFileStore;
+export declare class DocsRepository {
+    private readonly store;
+    constructor(store: DocsFileStore);
+    listNotes(docsRoot: string): Promise<DocsNote[]>;
+    readNote(path: string): Promise<DocsNote | null>;
+    writeNote(note: DocsNote): Promise<void>;
+}

package/dist/docs-repository.js

@@ -0,0 +1,75 @@
+import { isDocsDocumentPath } from "./docs-path";
+import { docsNoteToMarkdown, parseDocsNoteMarkdownFile, } from "./model";
+function parentFolder(path) {
+    const index = path.lastIndexOf("/");
+    return index > 0 ? path.slice(0, index) : null;
+}
+export function createVaultDocsFileStore(app) {
+    return {
+        async read(path) {
+            const file = app.vault.getFileByPath(path);
+            if (!file)
+                throw new Error(`Missing docs file: ${path}`);
+            return app.vault.cachedRead(file);
+        },
+        async write(path, content) {
+            const file = app.vault.getFileByPath(path);
+            if (file) {
+                await app.vault.modify(file, content);
+                return;
+            }
+            const folder = parentFolder(path);
+            if (folder)
+                await app.vault.mkpath(folder);
+            await app.vault.create(path, content);
+        },
+        async listMarkdown(root) {
+            const prefix = root.replace(/^\/+|\/+$/g, "");
+            return app.vault
+                .getFiles()
+                .map((file) => file.path)
+                .filter((path) => {
+                if (!isDocsDocumentPath(path))
+                    return false;
+                return (path === `${prefix}.doc.md` ||
+                    path.startsWith(`${prefix}/`) ||
+                    !prefix);
+            })
+                .sort();
+        },
+    };
+}
+export class DocsRepository {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    async listNotes(docsRoot) {
+        const paths = await this.store.listMarkdown(docsRoot);
+        const notes = [];
+        for (const path of paths) {
+            try {
+                const content = await this.store.read(path);
+                const parsed = parseDocsNoteMarkdownFile({ path, content });
+                if (parsed)
+                    notes.push(parsed);
+            }
+            catch {
+                // Skip unreadable or non-docs markdown.
+            }
+        }
+        return notes;
+    }
+    async readNote(path) {
+        try {
+            const content = await this.store.read(path);
+            return parseDocsNoteMarkdownFile({ path, content });
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeNote(note) {
+        await this.store.write(note.sourcePath, docsNoteToMarkdown(note));
+    }
+}

package/dist/docs-review-view.d.ts

@@ -0,0 +1,18 @@
+import { View, type WorkspaceLeaf } from "@lapis-notes/api";
+import type { DocsRepository } from "./docs-repository";
+import type { DocsSettingsSource } from "./docs-view";
+export declare const DOCS_REVIEW_VIEW_TYPE = "docs-review";
+export declare class DocsReviewView extends View {
+    private readonly repository;
+    private readonly clock;
+    private readonly settings?;
+    private component;
+    constructor(leaf: WorkspaceLeaf, repository: DocsRepository, clock?: () => Date, settings?: DocsSettingsSource | undefined);
+    getViewType(): string;
+    getDisplayText(): string;
+    getIcon(): string;
+    protected onOpen(): Promise<void>;
+    protected onClose(): Promise<void>;
+    onload(): void;
+    onunload(): void;
+}

package/dist/docs-review-view.js

@@ -0,0 +1,52 @@
+import { View } from "@lapis-notes/api";
+import { mount, unmount } from "svelte";
+import DocsWorkspace from "./docs-workspace.svelte";
+export const DOCS_REVIEW_VIEW_TYPE = "docs-review";
+export class DocsReviewView extends View {
+    repository;
+    clock;
+    settings;
+    component = null;
+    constructor(leaf, repository, clock = () => new Date(), settings) {
+        super(leaf);
+        this.repository = repository;
+        this.clock = clock;
+        this.settings = settings;
+    }
+    getViewType() {
+        return DOCS_REVIEW_VIEW_TYPE;
+    }
+    getDisplayText() {
+        return "Docs Review";
+    }
+    getIcon() {
+        return "brain";
+    }
+    onOpen() {
+        return Promise.resolve();
+    }
+    onClose() {
+        return Promise.resolve();
+    }
+    onload() {
+        this.containerEl.style.width = "100%";
+        this.containerEl.style.height = "100%";
+        this.containerEl.style.minHeight = "0";
+        this.containerEl.style.overflow = "hidden";
+        this.component = mount(DocsWorkspace, {
+            target: this.containerEl,
+            props: {
+                app: this.app,
+                repository: this.repository,
+                clock: this.clock,
+                settingsSource: this.settings,
+                mode: "review",
+            },
+        });
+    }
+    onunload() {
+        if (this.component)
+            void unmount(this.component);
+        this.component = null;
+    }
+}

package/dist/docs-settings-tab.d.ts

@@ -0,0 +1,8 @@
+import { PluginSettingTab, type App } from "@lapis-notes/api";
+import type { DocsPlugin } from "./docs-plugin";
+export declare class DocsSettingsTab extends PluginSettingTab {
+    private readonly docsPlugin;
+    constructor(app: App, docsPlugin: DocsPlugin);
+    display(): void;
+    private update;
+}

package/dist/docs-settings-tab.js

@@ -0,0 +1,25 @@
+import { Notice, PluginSettingTab, Setting } from "@lapis-notes/api";
+export class DocsSettingsTab extends PluginSettingTab {
+    docsPlugin;
+    constructor(app, docsPlugin) {
+        super(app, docsPlugin);
+        this.docsPlugin = docsPlugin;
+    }
+    display() {
+        const settings = this.docsPlugin.getSettings();
+        this.containerEl.empty();
+        new Setting(this.containerEl)
+            .setName("Docs root")
+            .setDesc("Vault folder that holds Docs notes.")
+            .addText((text) => text.setValue(settings.docsRoot).onChange((docsRoot) => void this.update({ docsRoot })));
+    }
+    async update(patch) {
+        try {
+            await this.docsPlugin.updateSettings(patch);
+            this.display();
+        }
+        catch (error) {
+            new Notice(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

package/dist/docs-settings.d.ts

@@ -0,0 +1,17 @@
+export declare const DOCS_PLUGIN_DATA_VERSION: 1;
+export type DocsPluginSettings = {
+    docsRoot: string;
+};
+export type DocsPluginSettingsPatch = {
+    docsRoot?: string;
+};
+export type DocsPluginDataV1 = {
+    version: typeof DOCS_PLUGIN_DATA_VERSION;
+    settings: DocsPluginSettings;
+};
+export declare const DEFAULT_DOCS_PLUGIN_SETTINGS: DocsPluginSettings;
+export declare function normalizeDocsRoot(value: unknown): string;
+export declare function cloneDocsPluginSettings(settings: DocsPluginSettings): DocsPluginSettings;
+export declare function mergeDocsPluginSettings(value: unknown): DocsPluginSettings;
+export declare function patchDocsPluginSettings(settings: DocsPluginSettings, patch: DocsPluginSettingsPatch): DocsPluginSettings;
+export declare function migrateDocsPluginData(value: unknown): DocsPluginDataV1;

package/dist/docs-settings.js

@@ -0,0 +1,38 @@
+export const DOCS_PLUGIN_DATA_VERSION = 1;
+export const DEFAULT_DOCS_PLUGIN_SETTINGS = Object.freeze({
+    docsRoot: "docs",
+});
+function recordValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+export function normalizeDocsRoot(value) {
+    if (typeof value !== "string")
+        return DEFAULT_DOCS_PLUGIN_SETTINGS.docsRoot;
+    const trimmed = value.trim().replace(/^\/+|\/+$/g, "");
+    return trimmed || DEFAULT_DOCS_PLUGIN_SETTINGS.docsRoot;
+}
+export function cloneDocsPluginSettings(settings) {
+    return { docsRoot: settings.docsRoot };
+}
+export function mergeDocsPluginSettings(value) {
+    const stored = recordValue(value);
+    return {
+        docsRoot: normalizeDocsRoot(stored.docsRoot),
+    };
+}
+export function patchDocsPluginSettings(settings, patch) {
+    return {
+        docsRoot: patch.docsRoot !== undefined
+            ? normalizeDocsRoot(patch.docsRoot)
+            : settings.docsRoot,
+    };
+}
+export function migrateDocsPluginData(value) {
+    const stored = recordValue(value);
+    return {
+        version: DOCS_PLUGIN_DATA_VERSION,
+        settings: mergeDocsPluginSettings(stored.settings ?? stored),
+    };
+}

package/dist/docs-view.d.ts

@@ -0,0 +1,22 @@
+import { View, type WorkspaceLeaf } from "@lapis-notes/api";
+import type { DocsRepository } from "./docs-repository";
+import type { DocsPluginSettings } from "./docs-settings";
+export declare const DOCS_VIEW_TYPE = "docs";
+export type DocsSettingsSource = {
+    get(): DocsPluginSettings;
+    subscribe(listener: (settings: DocsPluginSettings) => void): () => void;
+};
+export declare class DocsView extends View {
+    private readonly repository;
+    private readonly clock;
+    private readonly settings?;
+    private component;
+    constructor(leaf: WorkspaceLeaf, repository: DocsRepository, clock?: () => Date, settings?: DocsSettingsSource | undefined);
+    getViewType(): string;
+    getDisplayText(): string;
+    getIcon(): string;
+    protected onOpen(): Promise<void>;
+    protected onClose(): Promise<void>;
+    onload(): void;
+    onunload(): void;
+}

package/dist/docs-view.js

@@ -0,0 +1,51 @@
+import { View } from "@lapis-notes/api";
+import { mount, unmount } from "svelte";
+import DocsSidebarHost from "./docs/sidebar/DocsSidebarHost.svelte";
+export const DOCS_VIEW_TYPE = "docs";
+export class DocsView extends View {
+    repository;
+    clock;
+    settings;
+    component = null;
+    constructor(leaf, repository, clock = () => new Date(), settings) {
+        super(leaf);
+        this.repository = repository;
+        this.clock = clock;
+        this.settings = settings;
+    }
+    getViewType() {
+        return DOCS_VIEW_TYPE;
+    }
+    getDisplayText() {
+        return "Docs";
+    }
+    getIcon() {
+        return "book-open";
+    }
+    onOpen() {
+        return Promise.resolve();
+    }
+    onClose() {
+        return Promise.resolve();
+    }
+    onload() {
+        this.containerEl.style.width = "100%";
+        this.containerEl.style.height = "100%";
+        this.containerEl.style.minHeight = "0";
+        this.containerEl.style.overflow = "hidden";
+        this.component = mount(DocsSidebarHost, {
+            target: this.containerEl,
+            props: {
+                app: this.app,
+                repository: this.repository,
+                clock: this.clock,
+                docsRoot: this.settings?.get().docsRoot ?? "docs",
+            },
+        });
+    }
+    onunload() {
+        if (this.component)
+            void unmount(this.component);
+        this.component = null;
+    }
+}