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

package/dist/docs/sidebar/docs-source-folder-tree.js

@@ -0,0 +1,143 @@
+import { DEFAULT_DOCS_NOTE_SORT, sortDocsNotes } from './docs-note-sort';
+export const DOCS_SOURCE_ROOT_ID = '__docs-root__';
+function sourceRelativePath(note) {
+    const sourcePath = note.sourcePath?.replace(/^\/+/, '').replaceAll('\\', '/') ?? '';
+    for (const prefix of ['data/docs/', 'docs/']) {
+        if (sourcePath.startsWith(prefix))
+            return sourcePath.slice(prefix.length);
+    }
+    return sourcePath || `${note.id}.doc.md`;
+}
+function sourceFolderPath(note) {
+    const segments = sourceRelativePath(note).split('/').filter(Boolean);
+    segments.pop();
+    return segments.join('/');
+}
+function folderId(path) {
+    return path || DOCS_SOURCE_ROOT_ID;
+}
+function ensureChild(parent, path, label) {
+    let child = parent.children.find((item) => item.path === path);
+    if (!child) {
+        child = {
+            id: folderId(path),
+            path,
+            label,
+            count: 0,
+            isBook: false,
+            notes: [],
+            children: []
+        };
+        parent.children.push(child);
+    }
+    return child;
+}
+function bookIndexNote(notes) {
+    const bookNotes = notes.filter((note) => (note.book?.chapters?.length ?? 0) > 0);
+    if (!bookNotes.length)
+        return null;
+    return (bookNotes.find((note) => {
+        const file = sourceRelativePath(note).split('/').at(-1);
+        return file === 'index.md' || file === 'index.doc.md';
+    }) ??
+        bookNotes[0] ??
+        null);
+}
+function applyBookFolderLabel(node) {
+    if (node.id === DOCS_SOURCE_ROOT_ID) {
+        node.isBook = false;
+        return;
+    }
+    const indexNote = bookIndexNote(node.notes);
+    if (!indexNote) {
+        node.isBook = false;
+        return;
+    }
+    const title = indexNote.title.trim();
+    node.label = title || node.label;
+    node.isBook = true;
+}
+function finalizeNode(node, sortMode) {
+    node.notes = sortDocsNotes(node.notes, sortMode);
+    applyBookFolderLabel(node);
+    node.children = node.children
+        .map((child) => finalizeNode(child, sortMode))
+        .sort((left, right) => left.label.localeCompare(right.label));
+    node.count = node.notes.length + node.children.reduce((total, child) => total + child.count, 0);
+    return node;
+}
+export function createDocsSourceFolderTree(notes, sortMode = DEFAULT_DOCS_NOTE_SORT) {
+    const root = {
+        id: DOCS_SOURCE_ROOT_ID,
+        path: '',
+        label: 'Docs',
+        count: 0,
+        isBook: false,
+        notes: [],
+        children: []
+    };
+    for (const note of notes) {
+        const segments = sourceFolderPath(note).split('/').filter(Boolean);
+        let current = root;
+        for (let index = 0; index < segments.length; index += 1) {
+            const path = segments.slice(0, index + 1).join('/');
+            current = ensureChild(current, path, segments[index]);
+        }
+        current.notes.push(note);
+    }
+    return finalizeNode(root, sortMode);
+}
+function normalizeQuery(query) {
+    return query.trim().toLowerCase();
+}
+function noteMatchesQuery(note, query) {
+    const haystack = [note.title, note.id, note.sourcePath].join(' ').toLowerCase();
+    return haystack.includes(query);
+}
+function cloneNode(node) {
+    return {
+        ...node,
+        notes: [...node.notes],
+        children: node.children.map(cloneNode)
+    };
+}
+function filterNode(node, query, sortMode) {
+    const folderHaystack = [node.label, node.path || 'Docs', node.isBook ? 'book' : '']
+        .join(' ')
+        .toLowerCase();
+    if (folderHaystack.includes(query))
+        return finalizeNode(cloneNode(node), sortMode);
+    const notes = sortDocsNotes(node.notes.filter((note) => noteMatchesQuery(note, query)), sortMode);
+    const children = node.children
+        .map((child) => filterNode(child, query, sortMode))
+        .filter((child) => child !== null)
+        .sort((left, right) => left.label.localeCompare(right.label));
+    const count = notes.length + children.reduce((total, child) => total + child.count, 0);
+    if (count === 0)
+        return null;
+    const next = { ...node, notes, children, count };
+    applyBookFolderLabel(next);
+    return next;
+}
+export function filterDocsSourceFolderTree(tree, query, sortMode = DEFAULT_DOCS_NOTE_SORT) {
+    const normalized = normalizeQuery(query);
+    if (!normalized)
+        return finalizeNode(cloneNode(tree), sortMode);
+    return filterNode(tree, normalized, sortMode);
+}
+export function collectExpandableSourceFolderIds(node) {
+    const ids = [];
+    if (node.notes.length || node.children.length)
+        ids.push(node.id);
+    for (const child of node.children)
+        ids.push(...collectExpandableSourceFolderIds(child));
+    return ids;
+}
+export function sourceFolderAncestorIds(note) {
+    const segments = sourceFolderPath(note).split('/').filter(Boolean);
+    const ids = [DOCS_SOURCE_ROOT_ID];
+    for (let index = 0; index < segments.length; index += 1) {
+        ids.push(segments.slice(0, index + 1).join('/'));
+    }
+    return ids;
+}

package/dist/docs/sidebar/docs-tag-tree.d.ts

@@ -0,0 +1,17 @@
+import { docsNoteMatchesTagFolder, docsTagMatchesFolder, normalizeDocsTag, type DocsNoteSummary, type DocsTagSummary } from '../../model';
+export type DocsTagSortMode = 'count' | 'name';
+export type DocsTagTreeNode = {
+    name: string;
+    tag: string;
+    count: number;
+    exactCount: number;
+    summary: DocsTagSummary | null;
+    children: DocsTagTreeNode[];
+};
+export { docsNoteMatchesTagFolder, docsTagMatchesFolder, normalizeDocsTag };
+/** Folder badges count notes/files, not notes+cards. */
+export declare function docsTagCount(tag: DocsTagSummary): number;
+export declare function sortDocsTagSummaries(tags: DocsTagSummary[], sortMode: DocsTagSortMode): DocsTagSummary[];
+export declare function filterDocsTagsByPathMatch(tags: DocsTagSummary[], query: string): DocsTagSummary[];
+export declare function createDocsTagTree(tagSummaries: DocsTagSummary[], sortMode?: DocsTagSortMode): DocsTagTreeNode[];
+export declare function filterDocsNotesByTagFolder(notes: DocsNoteSummary[], folder: string): DocsNoteSummary[];

package/dist/docs/sidebar/docs-tag-tree.js

@@ -0,0 +1,84 @@
+import { docsNoteMatchesTagFolder, docsTagMatchesFolder, normalizeDocsTag } from '../../model';
+export { docsNoteMatchesTagFolder, docsTagMatchesFolder, normalizeDocsTag };
+/** Folder badges count notes/files, not notes+cards. */
+export function docsTagCount(tag) {
+    return tag.noteCount;
+}
+export function sortDocsTagSummaries(tags, sortMode) {
+    return [...tags].sort((left, right) => {
+        if (sortMode === 'name')
+            return left.tag.localeCompare(right.tag);
+        return docsTagCount(right) - docsTagCount(left) || left.tag.localeCompare(right.tag);
+    });
+}
+export function filterDocsTagsByPathMatch(tags, query) {
+    const needle = normalizeDocsTag(query).toLowerCase();
+    if (!needle)
+        return tags;
+    return tags.filter((tag) => {
+        const path = normalizeDocsTag(tag.tag).toLowerCase();
+        return (path === needle ||
+            path.startsWith(`${needle}/`) ||
+            path.includes(`/${needle}/`) ||
+            path.endsWith(`/${needle}`) ||
+            path.includes(needle));
+    });
+}
+export function createDocsTagTree(tagSummaries, sortMode = 'count') {
+    const nodeByPath = new Map();
+    const roots = [];
+    for (const summary of tagSummaries) {
+        const parts = summary.tag
+            .split('/')
+            .map((part) => part.trim())
+            .filter(Boolean);
+        if (!parts.length)
+            continue;
+        let parent = null;
+        for (let index = 0; index < parts.length; index += 1) {
+            const path = parts.slice(0, index + 1).join('/');
+            let node = nodeByPath.get(path);
+            if (!node) {
+                node = {
+                    name: parts[index],
+                    tag: path,
+                    count: 0,
+                    exactCount: 0,
+                    summary: null,
+                    children: []
+                };
+                nodeByPath.set(path, node);
+                if (parent)
+                    parent.children.push(node);
+                else
+                    roots.push(node);
+            }
+            if (index === parts.length - 1) {
+                node.summary = summary;
+                node.exactCount = docsTagCount(summary);
+            }
+            parent = node;
+        }
+    }
+    function assignCounts(node) {
+        const childrenCount = node.children.reduce((total, child) => total + assignCounts(child), 0);
+        node.count = node.summary ? node.exactCount : childrenCount;
+        return node.count;
+    }
+    function sortNodes(nodes) {
+        nodes.sort((left, right) => {
+            if (sortMode === 'name')
+                return left.name.localeCompare(right.name);
+            return right.count - left.count || left.name.localeCompare(right.name);
+        });
+        for (const node of nodes)
+            sortNodes(node.children);
+        return nodes;
+    }
+    for (const node of roots)
+        assignCounts(node);
+    return sortNodes(roots);
+}
+export function filterDocsNotesByTagFolder(notes, folder) {
+    return notes.filter((note) => docsNoteMatchesTagFolder(note, folder));
+}

package/dist/docs-cards-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_CARDS_VIEW_TYPE = "docs-cards";
+export declare class DocsCardsView 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-cards-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_CARDS_VIEW_TYPE = "docs-cards";
+export class DocsCardsView 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_CARDS_VIEW_TYPE;
+    }
+    getDisplayText() {
+        return "Docs Cards";
+    }
+    getIcon() {
+        return "layers";
+    }
+    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: "cards",
+            },
+        });
+    }
+    onunload() {
+        if (this.component)
+            void unmount(this.component);
+        this.component = null;
+    }
+}

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

@@ -0,0 +1,24 @@
+import { TextFileView, type TFile, type WorkspaceLeaf } from "@lapis-notes/api";
+import type { DocsRepository } from "./docs-repository";
+export declare class DocsDocumentView extends TextFileView {
+    private readonly repository?;
+    private readonly clock;
+    private component;
+    private readonly saves;
+    constructor(leaf?: WorkspaceLeaf, repository?: DocsRepository | undefined, clock?: () => Date);
+    getViewType(): string;
+    getDisplayText(): string;
+    getIcon(): string;
+    canAcceptExtension(extension: string): boolean;
+    getViewData(): string;
+    setViewData(data: string, _clear?: boolean): void;
+    clear(): void;
+    onload(): void;
+    onunload(): Promise<void>;
+    onUnloadFile(file: TFile): Promise<void>;
+    protected onClose(): Promise<void>;
+    private persistMarkdown;
+    private unmountWorkspace;
+    private fillLeafSurface;
+    private reload;
+}

package/dist/docs-document-view.js

@@ -0,0 +1,127 @@
+import { TextFileView, } from "@lapis-notes/api";
+import { mount, unmount } from "svelte";
+import { DOCS_DOCUMENT_VIEW_TYPE, isDocsDocumentPath, } from "./docs-path";
+import DocsDocumentWorkspace from "./docs-document-workspace.svelte";
+class DocsSaveCoordinator {
+    write;
+    chain = Promise.resolve();
+    pending = null;
+    constructor(write) {
+        this.write = write;
+    }
+    queue(request) {
+        this.pending = request;
+        this.chain = this.chain
+            .catch(() => undefined)
+            .then(async () => {
+            const next = this.pending;
+            this.pending = null;
+            if (!next)
+                return;
+            await this.write(next);
+        });
+        return this.chain;
+    }
+    flush() {
+        return this.chain;
+    }
+}
+export class DocsDocumentView extends TextFileView {
+    repository;
+    clock;
+    component = null;
+    saves = new DocsSaveCoordinator(async ({ file, value }) => this.app.vault.modify(file, value));
+    constructor(leaf, repository, clock = () => new Date()) {
+        super(leaf);
+        this.repository = repository;
+        this.clock = clock;
+    }
+    getViewType() {
+        return DOCS_DOCUMENT_VIEW_TYPE;
+    }
+    getDisplayText() {
+        return this.file?.baseName ?? "Docs";
+    }
+    getIcon() {
+        return "book-open";
+    }
+    canAcceptExtension(extension) {
+        const normalized = extension.toLowerCase().replace(/^\./, "");
+        if (normalized === "doc.md")
+            return true;
+        return isDocsDocumentPath(this.file?.path ?? "");
+    }
+    getViewData() {
+        return this.data;
+    }
+    setViewData(data, _clear) {
+        this.data = data;
+        this.editor.setValue(data);
+        this.reload();
+    }
+    clear() {
+        this.data = "";
+        this.editor.setValue("");
+        this.reload();
+    }
+    onload() {
+        this.reload();
+    }
+    async onunload() {
+        await this.saves.flush();
+        this.unmountWorkspace();
+    }
+    async onUnloadFile(file) {
+        await this.saves.flush();
+        await super.onUnloadFile(file);
+    }
+    async onClose() {
+        await this.saves.flush();
+        this.unmountWorkspace();
+    }
+    persistMarkdown(next) {
+        if (next === this.data)
+            return Promise.resolve();
+        this.data = next;
+        this.editor.setValue(next);
+        if (!this.file)
+            return Promise.resolve();
+        return this.saves.queue({ file: this.file.copy(), value: next });
+    }
+    unmountWorkspace() {
+        if (!this.component)
+            return;
+        unmount(this.component);
+        this.component = null;
+    }
+    fillLeafSurface(element) {
+        if (!element)
+            return;
+        element.style.display = "flex";
+        element.style.flexDirection = "column";
+        element.style.width = "100%";
+        element.style.height = "100%";
+        element.style.minHeight = "0";
+        element.style.overflow = "hidden";
+    }
+    reload() {
+        const target = this.contentEl ?? this.containerEl;
+        if (!target)
+            return;
+        this.unmountWorkspace();
+        target.empty();
+        this.fillLeafSurface(this.containerEl);
+        this.fillLeafSurface(target);
+        this.component = mount(DocsDocumentWorkspace, {
+            target,
+            props: {
+                app: this.app,
+                markdownText: this.data,
+                filePath: this.file?.path ?? "",
+                repository: this.repository,
+                clock: this.clock,
+                onMarkdownChange: (next) => this.persistMarkdown(next),
+            },
+        });
+    }
+}

package/dist/docs-document-workspace.svelte

@@ -0,0 +1,215 @@
+<script lang="ts">
+  /**
+   * File-leaf adapter: vault markdown ↔ ported DocsWorkspace for a single *.doc.md.
+   */
+  import type { App } from "@lapis-notes/api";
+  import { onDestroy } from "svelte";
+  import { docsPanelAfterPreviewToggle } from "./docs/docs-folder-directory";
+  import {
+    requestDocsDocumentSurface,
+    subscribeDocsDocumentSurface,
+  } from "./docs/docs-document-surface";
+  import DocsWorkspace from "./docs/DocsWorkspace.svelte";
+  import type { DocsRepository } from "./docs-repository";
+  import {
+    buildDocsWorkspace,
+    docsNoteToMarkdown,
+    parseDocsNoteMarkdownFile,
+    reviewDocsCard,
+    type DocsNote,
+    type DocsNotePanel,
+    type DocsReviewRating,
+    type DocsReviewScope,
+  } from "./model";
+
+  let {
+    app,
+    markdownText = "",
+    filePath = "",
+    repository,
+    clock = () => new Date(),
+    onMarkdownChange = async () => {},
+  }: {
+    app: App;
+    markdownText?: string;
+    filePath?: string;
+    repository?: DocsRepository;
+    clock?: () => Date;
+    onMarkdownChange?: (next: string) => void | Promise<void>;
+  } = $props();
+
+  let notes = $state<DocsNote[]>([]);
+  let activePanel = $state<DocsNotePanel>("display");
+  let reviewScope = $state<DocsReviewScope>("note");
+  let previewMode = $state(true);
+  let sidebarOpen = $state(true);
+  let loading = $state(false);
+  let saving = $state(false);
+  let error = $state<string | null>(null);
+
+  const activeNote = $derived.by(() => {
+    const parsed = parseDocsNoteMarkdownFile({
+      path: filePath || "untitled.doc.md",
+      content: markdownText,
+    });
+    return parsed;
+  });
+
+  const workspace = $derived.by(() => {
+    const catalog = notes.length
+      ? notes.map((note) =>
+          note.id === activeNote?.id && activeNote ? activeNote : note,
+        )
+      : activeNote
+        ? [activeNote]
+        : [];
+    return buildDocsWorkspace(catalog, clock());
+  });
+
+  async function refreshCatalog() {
+    if (!repository) {
+      notes = activeNote ? [activeNote] : [];
+      return;
+    }
+    loading = true;
+    try {
+      const listed = await repository.listNotes("docs");
+      notes = listed.length ? listed : activeNote ? [activeNote] : [];
+      error = null;
+    } catch (err) {
+      error = err instanceof Error ? err.message : String(err);
+      notes = activeNote ? [activeNote] : [];
+    } finally {
+      loading = false;
+    }
+  }
+
+  $effect(() => {
+    void filePath;
+    void markdownText;
+    void refreshCatalog();
+  });
+
+  $effect(() => {
+    if (!filePath) return;
+    return subscribeDocsDocumentSurface(filePath, (surface) => {
+      activePanel = surface.panel;
+      if (surface.reviewScope) reviewScope = surface.reviewScope;
+      if (surface.panel === "display" || surface.panel === "note") {
+        previewMode = surface.panel !== "note";
+      }
+    });
+  });
+
+  async function persistNote(note: DocsNote) {
+    saving = true;
+    try {
+      const next = docsNoteToMarkdown(note);
+      await onMarkdownChange(next);
+      if (repository) await repository.writeNote(note);
+      error = null;
+    } catch (err) {
+      error = err instanceof Error ? err.message : String(err);
+    } finally {
+      saving = false;
+    }
+  }
+
+  async function handleReview(
+    noteId: string,
+    cardId: string,
+    rating: DocsReviewRating,
+  ) {
+    const note =
+      notes.find((entry) => entry.id === noteId) ??
+      (activeNote?.id === noteId ? activeNote : null);
+    if (!note) return;
+    const card = note.cards.find((entry) => entry.id === cardId);
+    if (!card) return;
+    const nextCard = reviewDocsCard(card, rating, clock());
+    const nextNote: DocsNote = {
+      ...note,
+      cards: note.cards.map((entry) =>
+        entry.id === cardId ? nextCard : entry,
+      ),
+      updatedAt: clock().toISOString(),
+    };
+    await persistNote(nextNote);
+    await refreshCatalog();
+  }
+
+  onDestroy(() => {
+    // Flush is owned by DocsDocumentView save coordinator.
+  });
+
+  // app used in openLinkText callback
+</script>
+
+<div
+  class="docs-document-workspace"
+  data-ui-component="docs-document"
+  data-docs-ready={activeNote ? "true" : "false"}
+>
+  <DocsWorkspace
+    {workspace}
+    activeNote={activeNote}
+    activeNoteId={activeNote?.id ?? null}
+    {activePanel}
+    {reviewScope}
+    {previewMode}
+    {sidebarOpen}
+    {loading}
+    {saving}
+    {error}
+    onToggleSidebar={() => {
+      sidebarOpen = !sidebarOpen;
+    }}
+    onActiveNoteChange={(noteId) => {
+      if (!noteId || !repository) return;
+      const target = notes.find((note) => note.id === noteId);
+      if (!target?.sourcePath) return;
+      const file = app.vault.getFileByPath(target.sourcePath);
+      if (!file) return;
+      requestDocsDocumentSurface(target.sourcePath, { panel: "display" });
+      void app.workspace.openLinkText(target.sourcePath, "", false);
+    }}
+    onActivePanelChange={(panel) => {
+      activePanel = panel;
+      if (panel === "display" || panel === "note") {
+        previewMode = panel === "display";
+      }
+    }}
+    onReviewScopeChange={(scope) => {
+      reviewScope = scope;
+    }}
+    onPreviewModeChange={(enabled) => {
+      previewMode = enabled;
+      activePanel = docsPanelAfterPreviewToggle(activePanel, enabled);
+    }}
+    onSaveNote={persistNote}
+    onReviewCard={handleReview}
+    onImportAnkiPackage={async (file) => {
+      if (!repository) return;
+      const { importAnkiPackageFile } = await import("./docs/import-anki-package");
+      await importAnkiPackageFile({
+        app,
+        repository,
+        docsRoot: "docs",
+        file,
+        now: clock(),
+      });
+      await refreshCatalog();
+    }}
+  />
+</div>
+
+<style>
+  .docs-document-workspace {
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    height: 100%;
+    min-height: 0;
+    overflow: hidden;
+  }
+</style>

package/dist/docs-document-workspace.svelte.d.ts

@@ -0,0 +1,16 @@
+/**
+   * File-leaf adapter: vault markdown ↔ ported DocsWorkspace for a single *.doc.md.
+   */
+import type { App } from "@lapis-notes/api";
+import type { DocsRepository } from "./docs-repository";
+type $$ComponentProps = {
+    app: App;
+    markdownText?: string;
+    filePath?: string;
+    repository?: DocsRepository;
+    clock?: () => Date;
+    onMarkdownChange?: (next: string) => void | Promise<void>;
+};
+declare const DocsDocumentWorkspace: import("svelte").Component<$$ComponentProps, {}, "">;
+type DocsDocumentWorkspace = ReturnType<typeof DocsDocumentWorkspace>;
+export default DocsDocumentWorkspace;