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

package/dist/docs/docs-display-focus.d.ts

@@ -0,0 +1,7 @@
+import type { DocsNote } from '../model';
+export declare function displaySlideCount(note: DocsNote | null | undefined): number;
+export declare function clampDisplaySlideIndex(index: number, note: DocsNote | null | undefined): number;
+/** Block label "05" maps to slide index 5 (intro is 0). */
+export declare function slideIndexForBlockIndex(blockIndex: number): number;
+export declare function displayFocusSelector(note: DocsNote, slideIndex: number): string;
+export declare function readVisibleDisplaySlideIndex(root: HTMLElement, scrollRoot: Element | null): number;

package/dist/docs/docs-display-focus.js

@@ -0,0 +1,42 @@
+export function displaySlideCount(note) {
+    if (!note)
+        return 0;
+    return 1 + note.blocks.length + (note.body.trim() ? 1 : 0);
+}
+export function clampDisplaySlideIndex(index, note) {
+    const count = displaySlideCount(note);
+    if (count <= 0)
+        return 0;
+    return Math.max(0, Math.min(index, count - 1));
+}
+/** Block label "05" maps to slide index 5 (intro is 0). */
+export function slideIndexForBlockIndex(blockIndex) {
+    return blockIndex + 1;
+}
+export function displayFocusSelector(note, slideIndex) {
+    const clamped = clampDisplaySlideIndex(slideIndex, note);
+    if (clamped === 0)
+        return `[data-display-slide-index="0"]`;
+    if (clamped <= note.blocks.length) {
+        return `[data-display-slide-index="${clamped}"]`;
+    }
+    return `[data-display-slide-index="${note.blocks.length + 1}"]`;
+}
+export function readVisibleDisplaySlideIndex(root, scrollRoot) {
+    const targets = Array.from(root.querySelectorAll('[data-display-slide-index]'));
+    if (!targets.length)
+        return 0;
+    const viewportTop = scrollRoot?.getBoundingClientRect().top ?? 0;
+    const focusLine = viewportTop + 56;
+    let bestIndex = 0;
+    for (const target of targets) {
+        const index = Number(target.dataset.displaySlideIndex);
+        if (!Number.isFinite(index))
+            continue;
+        const rect = target.getBoundingClientRect();
+        // Classic scrollspy: the active section is the last one at or above the focus line.
+        if (rect.top <= focusLine)
+            bestIndex = index;
+    }
+    return bestIndex;
+}

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

@@ -0,0 +1,7 @@
+import type { DocsNotePanel, DocsReviewScope } from "../model";
+export type DocsDocumentSurface = {
+    panel: DocsNotePanel;
+    reviewScope?: DocsReviewScope;
+};
+export declare function requestDocsDocumentSurface(path: string, surface: DocsDocumentSurface): void;
+export declare function subscribeDocsDocumentSurface(path: string, listener: (surface: DocsDocumentSurface) => void): () => void;

package/dist/docs/docs-document-surface.js

@@ -0,0 +1,25 @@
+import { resolveDocsSidebarPanelSelection, } from "./docs-folder-directory";
+const pending = new Map();
+const listeners = new Map();
+export function requestDocsDocumentSurface(path, surface) {
+    const next = {
+        panel: resolveDocsSidebarPanelSelection(surface.panel),
+        ...(surface.reviewScope ? { reviewScope: surface.reviewScope } : {}),
+    };
+    pending.set(path, next);
+    for (const listener of listeners.get(path) ?? [])
+        listener(next);
+}
+export function subscribeDocsDocumentSurface(path, listener) {
+    const group = listeners.get(path) ?? new Set();
+    group.add(listener);
+    listeners.set(path, group);
+    const current = pending.get(path);
+    if (current)
+        listener(current);
+    return () => {
+        group.delete(listener);
+        if (group.size === 0)
+            listeners.delete(path);
+    };
+}

package/dist/docs/docs-folder-directory.d.ts

@@ -0,0 +1,21 @@
+import { type DocsNoteListItem } from '../model/docs-note-list';
+import type { DocsNotePanel, DocsWorkspace, DocsWorkspaceIndex } from '../model';
+export type FolderNotePanel = {
+    id: DocsNotePanel;
+    label: string;
+    count?: number;
+};
+export declare function getFolderNotes(workspace: DocsWorkspace | DocsWorkspaceIndex | null | undefined, activeTag: string | null | undefined): (import("..").DocsNote | import("..").DocsNoteSummary)[];
+export declare function getActiveFolderNote(folderNotes: DocsNoteListItem[], activeNoteId: string | null | undefined): DocsNoteListItem | null;
+export declare function getMatchingFolderTags(activeTag: string | null | undefined, activeFolderNote: DocsNoteListItem | null | undefined): string[];
+export declare function getActiveFolderTagKey(activeTag: string | null | undefined): string;
+export declare function getFolderNotePanels(workspace: DocsWorkspace | DocsWorkspaceIndex | null | undefined, note: DocsNoteListItem): FolderNotePanel[];
+/** Sidebar "Note" opens the display/preview surface, not the editor. */
+export declare function resolveDocsSidebarPanelSelection(panel: DocsNotePanel): DocsNotePanel;
+/**
+ * The toolbar preview toggle edits cards in place. Note and display still
+ * trade places with that same control.
+ */
+export declare function docsPanelAfterPreviewToggle(activePanel: DocsNotePanel, previewMode: boolean): DocsNotePanel;
+/** Keep the Note row highlighted while preview (display) or edit (note) is active. */
+export declare function isDocsSidebarPanelActive(activePanel: DocsNotePanel, panel: DocsNotePanel): boolean;

package/dist/docs/docs-folder-directory.js

@@ -0,0 +1,56 @@
+import { docsNoteMatchesTagFolder, docsNoteTagValues, docsTagMatchesFolder, normalizeDocsTag, } from '../model/graph';
+import { docsNoteCardCount } from '../model/docs-note-list';
+export function getFolderNotes(workspace, activeTag) {
+    if (!workspace || !activeTag)
+        return [];
+    return workspace.notes
+        .filter((note) => docsNoteMatchesTagFolder(note, activeTag))
+        .sort((left, right) => left.title.localeCompare(right.title));
+}
+export function getActiveFolderNote(folderNotes, activeNoteId) {
+    return folderNotes.find((note) => note.id === activeNoteId) ?? null;
+}
+export function getMatchingFolderTags(activeTag, activeFolderNote) {
+    if (!activeTag || !activeFolderNote)
+        return [];
+    const tags = new Set();
+    for (const tag of docsNoteTagValues(activeFolderNote)) {
+        if (docsTagMatchesFolder(tag, activeTag)) {
+            tags.add(normalizeDocsTag(tag));
+        }
+    }
+    return [...tags].sort((left, right) => left.localeCompare(right));
+}
+export function getActiveFolderTagKey(activeTag) {
+    return normalizeDocsTag(activeTag ?? "").toLowerCase();
+}
+function noteDueCount(workspace, noteId) {
+    return (workspace?.reviewQueue.filter((item) => item.noteId === noteId).length ?? 0);
+}
+export function getFolderNotePanels(workspace, note) {
+    return [
+        { id: "note", label: "Note" },
+        { id: "cards", label: "Cards", count: docsNoteCardCount(note) },
+        { id: "review", label: "Review", count: noteDueCount(workspace, note.id) },
+    ];
+}
+/** Sidebar "Note" opens the display/preview surface, not the editor. */
+export function resolveDocsSidebarPanelSelection(panel) {
+    return panel === "note" ? "display" : panel;
+}
+/**
+ * The toolbar preview toggle edits cards in place. Note and display still
+ * trade places with that same control.
+ */
+export function docsPanelAfterPreviewToggle(activePanel, previewMode) {
+    if (activePanel === "cards")
+        return "cards";
+    return previewMode ? "display" : "note";
+}
+/** Keep the Note row highlighted while preview (display) or edit (note) is active. */
+export function isDocsSidebarPanelActive(activePanel, panel) {
+    if (panel === "note") {
+        return activePanel === "note" || activePanel === "display";
+    }
+    return activePanel === panel;
+}

package/dist/docs/docs-link-mode.d.ts

@@ -0,0 +1,16 @@
+import type { DocsNotePanel } from '../model';
+export type DocsContentLinkTarget = {
+    noteId: string;
+    /** The id is present in the loaded Docs catalog, so the link can open it. */
+    open: boolean;
+};
+/** Note id carried by a Docs content link, including card resource and wiki targets. */
+export declare function docsContentLinkTarget(href: string, noteIds: ReadonlySet<string>): DocsContentLinkTarget | null;
+/**
+ * Opens a Docs note from a rendered content link.
+ * Protocol links are cancelled even when the note is not in the catalog.
+ */
+export declare function openDocsContentLink(event: MouseEvent, notes: readonly {
+    id: string;
+}[], openNote: (noteId: string) => void): boolean;
+export declare function preservePreviewModeForDocsLink(event: MouseEvent, activePanel: DocsNotePanel): void;

package/dist/docs/docs-link-mode.js

@@ -0,0 +1,94 @@
+const DOCS_PROTOCOL_LINK = /^(?:cvstudio|lapis):\/\/docs\/([^/?#]+)(?:[/?#].*)?$/i;
+/** Note id carried by a Docs content link, including card resource and wiki targets. */
+export function docsContentLinkTarget(href, noteIds) {
+    const raw = href.trim();
+    if (!raw || raw.startsWith("#"))
+        return null;
+    const protocol = raw.match(DOCS_PROTOCOL_LINK);
+    if (protocol) {
+        const noteId = decodeNoteId(protocol[1] ?? "");
+        return noteId ? { noteId, open: noteIds.has(noteId) } : null;
+    }
+    const queryNote = docsNoteIdFromWorkspaceHref(raw);
+    if (queryNote)
+        return { noteId: queryNote, open: noteIds.has(queryNote) };
+    const bare = decodeNoteId(raw.split("#")[0] ?? "");
+    if (!bare || bare.includes("/") || bare.includes(":"))
+        return null;
+    if (!noteIds.has(bare))
+        return null;
+    return { noteId: bare, open: true };
+}
+/**
+ * Opens a Docs note from a rendered content link.
+ * Protocol links are cancelled even when the note is not in the catalog.
+ */
+export function openDocsContentLink(event, notes, openNote) {
+    if (event.defaultPrevented || event.button !== 0)
+        return false;
+    if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey)
+        return false;
+    if (!(event.target instanceof Element))
+        return false;
+    const anchor = event.target.closest("a[href]");
+    const href = anchor?.getAttribute("href");
+    if (!href)
+        return false;
+    const target = docsContentLinkTarget(href, new Set(notes.map((note) => note.id)));
+    if (!target)
+        return false;
+    event.preventDefault();
+    if (target.open)
+        openNote(target.noteId);
+    return true;
+}
+function decodeNoteId(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return "";
+    try {
+        return decodeURIComponent(trimmed);
+    }
+    catch {
+        return trimmed;
+    }
+}
+function docsNoteIdFromWorkspaceHref(href) {
+    if (!href.includes("note=") || /^[a-z][a-z0-9+.-]*:/i.test(href))
+        return null;
+    try {
+        const url = new URL(href, "http://docs.local");
+        const note = url.searchParams.get("note")?.trim();
+        if (url.searchParams.get("workspace") !== "docs" || !note)
+            return null;
+        return decodeNoteId(note);
+    }
+    catch {
+        return null;
+    }
+}
+export function preservePreviewModeForDocsLink(event, activePanel) {
+    if (event.defaultPrevented || activePanel !== "display")
+        return;
+    if (typeof window === "undefined")
+        return;
+    if (!(event.target instanceof Element))
+        return;
+    const anchor = event.target.closest("a[href]");
+    if (!anchor)
+        return;
+    const url = new URL(anchor.href, window.location.href);
+    if (url.origin !== window.location.origin)
+        return;
+    if (url.searchParams.get("workspace") !== "docs")
+        return;
+    if (!url.searchParams.get("note"))
+        return;
+    if (url.searchParams.has("preview") ||
+        url.searchParams.has("edit") ||
+        url.searchParams.has("docsPanel")) {
+        return;
+    }
+    url.searchParams.set("preview", "1");
+    anchor.href = `${url.pathname}${url.search}${url.hash}`;
+}

package/dist/docs/docs-workspace-helpers.d.ts

@@ -0,0 +1,25 @@
+import type { DocsCalloutTone, DocsDocType, DocsNote, DocsResourceItem, DocsRevisionBlock } from '../model';
+export type DisplayMode = 'document' | 'slides';
+export declare const DOC_TYPE_OPTIONS: DocsDocType[];
+export declare const DOC_TYPE_LABELS: Record<string, string>;
+export declare const BLOCK_TYPE_OPTIONS: DocsRevisionBlock['type'][];
+export declare const BLOCK_TYPE_LABELS: Record<string, string>;
+export declare const CALLOUT_TONE_OPTIONS: DocsCalloutTone[];
+export declare const CALLOUT_TONE_LABELS: Record<string, string>;
+export declare const DISPLAY_MODE_LABELS: Record<string, string>;
+export declare function cloneDocsNote(note: DocsNote): DocsNote;
+export declare function createEmptyDocsBlock(type: DocsRevisionBlock['type'], id: string, title?: string): DocsRevisionBlock;
+export declare function docsBlockDisplayTitle(block: DocsRevisionBlock): string;
+export declare function docsBlockPlainText(block: DocsRevisionBlock): string;
+export declare function createDocsBlockFromType(type: DocsRevisionBlock['type'], id: string, previous?: DocsRevisionBlock): DocsRevisionBlock;
+export declare function textToLines(value: string): string[];
+export declare function linesToText(items: string[]): string;
+export declare function tableRowsToText(rows: string[][]): string;
+export declare function textToTableRows(value: string): string[][];
+export declare function resourceItemsToText(items: DocsResourceItem[]): string;
+export declare function textToResourceItems(value: string): {
+    title: string;
+    url: string;
+    kind: string;
+    notes: string;
+}[];

package/dist/docs/docs-workspace-helpers.js

@@ -0,0 +1,195 @@
+export const DOC_TYPE_OPTIONS = [
+    'revision',
+    'coding-drill',
+    'system-design',
+    'story-bank',
+    'index',
+    'freeform'
+];
+export const DOC_TYPE_LABELS = {
+    revision: 'Revision',
+    'coding-drill': 'Coding drill',
+    'system-design': 'System design',
+    'story-bank': 'Story bank',
+    index: 'Index',
+    freeform: 'Freeform'
+};
+export const BLOCK_TYPE_OPTIONS = [
+    'text',
+    'markdown',
+    'concept',
+    'procedure',
+    'prompt',
+    'code',
+    'table',
+    'callout',
+    'story',
+    'resources'
+];
+export const BLOCK_TYPE_LABELS = {
+    text: 'Text',
+    markdown: 'Markdown',
+    concept: 'Concept',
+    procedure: 'Procedure',
+    prompt: 'Prompt',
+    code: 'Code',
+    table: 'Table',
+    callout: 'Callout',
+    story: 'Story',
+    resources: 'Resources'
+};
+export const CALLOUT_TONE_OPTIONS = ['note', 'tip', 'warning', 'critical'];
+export const CALLOUT_TONE_LABELS = {
+    note: 'Note',
+    tip: 'Tip',
+    warning: 'Warning',
+    critical: 'Critical'
+};
+export const DISPLAY_MODE_LABELS = {
+    document: 'Document',
+    slides: 'Slides'
+};
+export function cloneDocsNote(note) {
+    return JSON.parse(JSON.stringify(note));
+}
+export function createEmptyDocsBlock(type, id, title = '') {
+    const base = title.trim() ? { id, type, title: title.trim() } : { id, type };
+    switch (type) {
+        case 'concept':
+            return { ...base, type, summary: '', keyPoints: [], details: '' };
+        case 'procedure':
+            return { ...base, type, steps: [], notes: '' };
+        case 'prompt':
+            return {
+                ...base,
+                type,
+                problem: '',
+                requirements: [],
+                approach: '',
+                traps: [],
+                tests: [],
+                answer: ''
+            };
+        case 'code':
+            return { ...base, type, language: 'ts', code: '', caption: '' };
+        case 'table':
+            return { ...base, type, columns: [], rows: [] };
+        case 'callout':
+            return { ...base, type, tone: 'note', body: '' };
+        case 'story':
+            return {
+                ...base,
+                type,
+                useFor: [],
+                situation: '',
+                task: '',
+                action: '',
+                result: '',
+                metrics: []
+            };
+        case 'resources':
+            return { ...base, type, items: [] };
+        case 'markdown':
+            return { ...base, type: 'markdown', body: '' };
+        case 'text':
+        default:
+            return { ...base, type: 'text', body: '' };
+    }
+}
+export function docsBlockDisplayTitle(block) {
+    return block.title?.trim() || BLOCK_TYPE_LABELS[block.type];
+}
+export function docsBlockPlainText(block) {
+    switch (block.type) {
+        case 'concept':
+            return [block.summary, block.details].filter(Boolean).join('\n\n');
+        case 'procedure':
+            return [block.steps.join('\n'), block.notes].filter(Boolean).join('\n\n');
+        case 'prompt':
+            return [block.problem, block.approach, block.answer].filter(Boolean).join('\n\n');
+        case 'code':
+            return block.code;
+        case 'table':
+            return tableRowsToText(block.rows);
+        case 'callout':
+            return block.body;
+        case 'story':
+            return [block.situation, block.task, block.action, block.result].filter(Boolean).join('\n\n');
+        case 'resources':
+            return resourceItemsToText(block.items);
+        case 'markdown':
+        case 'text':
+        default:
+            return block.body;
+    }
+}
+export function createDocsBlockFromType(type, id, previous) {
+    const block = createEmptyDocsBlock(type, previous?.id ?? id, previous?.title ?? '');
+    const body = previous ? docsBlockPlainText(previous) : '';
+    if (!body)
+        return block;
+    switch (block.type) {
+        case 'concept':
+            return { ...block, summary: body };
+        case 'procedure':
+            return { ...block, notes: body };
+        case 'prompt':
+            return { ...block, problem: body };
+        case 'code':
+            return { ...block, code: body };
+        case 'callout':
+            return { ...block, body };
+        case 'story':
+            return { ...block, situation: body };
+        case 'resources':
+            return { ...block, items: textToResourceItems(body) };
+        case 'table':
+            return { ...block, rows: textToTableRows(body) };
+        case 'markdown':
+        case 'text':
+        default:
+            return { ...block, body };
+    }
+}
+export function textToLines(value) {
+    return value
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+export function linesToText(items) {
+    return items.join('\n');
+}
+export function tableRowsToText(rows) {
+    return rows.map((row) => row.join(' | ')).join('\n');
+}
+export function textToTableRows(value) {
+    return value
+        .split('\n')
+        .map((line) => line.split('|').map((cell) => cell.trim()))
+        .filter((row) => row.some(Boolean));
+}
+export function resourceItemsToText(items) {
+    return items
+        .map((item) => {
+        const heading = item.title || item.url;
+        const details = [item.url && item.title ? item.url : '', item.kind, item.notes].filter(Boolean);
+        return [heading, ...details].filter(Boolean).join('\n');
+    })
+        .filter(Boolean)
+        .join('\n\n');
+}
+export function textToResourceItems(value) {
+    const lines = textToLines(value);
+    if (!lines.length)
+        return [];
+    const [title = '', ...notes] = lines;
+    return [
+        {
+            title,
+            url: '',
+            kind: '',
+            notes: notes.join('\n')
+        }
+    ].filter((item) => item.title || item.notes);
+}

package/dist/docs/docs.tokens.css

@@ -0,0 +1,13 @@
+/* DESIGN_CORE_CANDIDATE: Docs domain tokens. Prefer shared design-core docs
+ * family when one exists. */
+:root,
+[data-ui-theme] {
+  --ui-docs-background: var(--ui-background, #fff);
+  --ui-docs-foreground: var(--ui-foreground, #111);
+  --ui-docs-muted: var(--ui-muted, #f4f4f5);
+  --ui-docs-muted-foreground: var(--ui-muted-foreground, #71717a);
+  --ui-docs-border: var(--ui-border, #e4e4e7);
+  --ui-docs-accent: var(--ui-primary, #2563eb);
+  --ui-docs-radius: var(--ui-radius, 0.5rem);
+  --ui-docs-card: var(--ui-card, #fff);
+}

package/dist/docs/import-anki-package.d.ts

@@ -0,0 +1,10 @@
+import type { App } from "@lapis-notes/api";
+import type { DocsRepository } from "../docs-repository";
+import type { AnkiImportResult } from "./docs-anki-import";
+export declare function importAnkiPackageFile(input: {
+    app: App;
+    repository: DocsRepository;
+    docsRoot: string;
+    file: File;
+    now?: Date;
+}): Promise<AnkiImportResult>;

package/dist/docs/import-anki-package.js

@@ -0,0 +1,30 @@
+function arrayBuffer(bytes) {
+    const copy = new Uint8Array(bytes.byteLength);
+    copy.set(bytes);
+    return copy.buffer;
+}
+export async function importAnkiPackageFile(input) {
+    const { importAnkiPackage } = await import("./docs-anki-import");
+    const existing = await input.repository.listNotes(input.docsRoot);
+    return importAnkiPackage({
+        bytes: new Uint8Array(await input.file.arrayBuffer()),
+        filename: input.file.name,
+        docsRoot: input.docsRoot,
+        now: input.now,
+        existingIds: existing.map((note) => note.id),
+        writeNote: (note) => input.repository.writeNote(note),
+        writeMedia: async (note, file) => {
+            const path = `${input.docsRoot}/anki/${note.id}/media/${file.filename}`;
+            const folder = path.slice(0, path.lastIndexOf("/"));
+            if (folder)
+                await input.app.vault.mkpath(folder);
+            const data = arrayBuffer(file.bytes);
+            const current = input.app.vault.getFileByPath(path);
+            if (current) {
+                await input.app.vault.modifyBinary(current, data);
+                return;
+            }
+            await input.app.vault.createBinary(path, data);
+        },
+    });
+}

package/dist/docs/lapis-markdown-extensions.d.ts

@@ -0,0 +1,9 @@
+import type { App } from "@lapis-notes/api";
+import { type MiraExtension } from "@lapismd/mira/extensions";
+/** Host stubs take no arguments. A provided renderer accepts the markdown string. */
+export declare function providedMarkdownRenderer(app: App | null): ((markdown: string, el: HTMLElement, sourcePath: string, component: import("@lapis-notes/api").Component) => Promise<void>) | null;
+/**
+ * Reading extensions used by the Lapis Markdown view: Mira's Mermaid plugin
+ * plus every Markdown post-processor registered with the host.
+ */
+export declare function lapisMarkdownExtensions(app: App | null, sourcePath: string, markdown: string): MiraExtension[];