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

package/dist/docs/sidebar/DocsTagsSidebar.svelte

@@ -0,0 +1,176 @@
+<script lang="ts">
+  import ChevronRightIcon from "@lucide/svelte/icons/chevron-right";
+  import FolderTreeIcon from "@lucide/svelte/icons/folder-tree";
+  import HashIcon from "@lucide/svelte/icons/hash";
+  import ListIcon from "@lucide/svelte/icons/list";
+  import { Button } from "@lapismd/design-core/shadcn/button";
+  import type { DocsTagSummary } from "../../model";
+  import type { DocsTagsViewMode } from "./docs-sidebar-ui-storage";
+  import {
+    createDocsTagTree,
+    docsTagCount,
+    filterDocsTagsByPathMatch,
+    normalizeDocsTag,
+    sortDocsTagSummaries,
+    type DocsTagSortMode,
+    type DocsTagTreeNode,
+  } from "./docs-tag-tree";
+
+  let {
+    tags = [],
+    selectedTags = [],
+    viewMode = $bindable<DocsTagsViewMode>("tree"),
+    openNodes = $bindable<Record<string, boolean>>({}),
+    onSelectTag = () => {},
+  }: {
+    tags?: DocsTagSummary[];
+    selectedTags?: string[];
+    viewMode?: DocsTagsViewMode;
+    openNodes?: Record<string, boolean>;
+    onSelectTag?: (tag: string) => void;
+  } = $props();
+
+  let query = $state("");
+  let sortMode = $state<DocsTagSortMode>("count");
+
+  const filteredTags = $derived(sortDocsTagSummaries(filterDocsTagsByPathMatch(tags, query), sortMode));
+  const tree = $derived(createDocsTagTree(filteredTags, sortMode));
+  const selectedTagSet = $derived(
+    new Set(selectedTags.map((tag) => normalizeDocsTag(tag).toLowerCase()).filter(Boolean)),
+  );
+  const hierarchyLabel = $derived(
+    viewMode === "tree"
+      ? "Showing tag hierarchy. Switch to flat tags."
+      : "Showing flat tags. Switch to tag hierarchy.",
+  );
+
+  function isOpen(tag: string) {
+    return openNodes[tag] !== false;
+  }
+
+  function toggle(tag: string) {
+    openNodes = { ...openNodes, [tag]: !isOpen(tag) };
+  }
+
+  function selectTag(tag: string) {
+    const normalized = normalizeDocsTag(tag);
+    if (normalized) onSelectTag(normalized);
+  }
+
+  function isSelected(tag: string) {
+    return selectedTagSet.has(normalizeDocsTag(tag).toLowerCase());
+  }
+</script>
+
+<div class="docs-tags">
+  <div class="docs-tags__tools">
+    <input class="docs-sidebar__search" placeholder="Search tags" bind:value={query} />
+    <Button
+      type="button"
+      variant="ghost"
+      size="icon-sm"
+      class="docs-tags__mode"
+      aria-pressed={viewMode === "tree"}
+      aria-label={hierarchyLabel}
+      title={hierarchyLabel}
+      onclick={() => (viewMode = viewMode === "tree" ? "flat" : "tree")}
+    >
+      {#if viewMode === "tree"}
+        <FolderTreeIcon aria-hidden="true" />
+      {:else}
+        <ListIcon aria-hidden="true" />
+      {/if}
+    </Button>
+  </div>
+
+  <div class="docs-sidebar__segment" role="group" aria-label="Sort tags">
+    <Button
+      type="button"
+      variant="ghost"
+      size="sm"
+      class="docs-sidebar__view"
+      aria-pressed={sortMode === "count"}
+      onclick={() => (sortMode = "count")}
+    >
+      <span class="docs-sidebar__view-label">Frequency</span>
+    </Button>
+    <Button
+      type="button"
+      variant="ghost"
+      size="sm"
+      class="docs-sidebar__view"
+      aria-pressed={sortMode === "name"}
+      onclick={() => (sortMode = "name")}
+    >
+      <span class="docs-sidebar__view-label">Name</span>
+    </Button>
+  </div>
+
+  {#if viewMode === "tree"}
+    <div class="docs-sidebar__group">
+      {#each tree as node (node.tag)}
+        {@render tagNode(node, 0)}
+      {:else}
+        <p class="docs-sidebar__empty">No tags match the current filter.</p>
+      {/each}
+    </div>
+  {:else}
+    <div class="docs-sidebar__group">
+      {#each filteredTags as tag (tag.tag)}
+        <button
+          type="button"
+          class="docs-sidebar__row"
+          aria-pressed={isSelected(tag.tag)}
+          title={`#${tag.tag}`}
+          onclick={() => selectTag(tag.tag)}
+        >
+          <HashIcon class="docs-sidebar__hash" aria-hidden="true" />
+          <span class="docs-sidebar__label">{tag.tag}</span>
+          <span class="docs-sidebar__count">{docsTagCount(tag)}</span>
+        </button>
+      {:else}
+        <p class="docs-sidebar__empty">No tags match the current filter.</p>
+      {/each}
+    </div>
+  {/if}
+</div>
+
+{#snippet tagNode(node: DocsTagTreeNode, depth: number)}
+  {@const expanded = node.children.length > 0 && isOpen(node.tag)}
+  <div class="docs-sidebar__group">
+    <div class="docs-tags__row" style={`padding-inline-start: ${depth * 0.85}rem`}>
+      {#if node.children.length}
+        <button
+          type="button"
+          class="docs-sidebar__chevron"
+          aria-label={expanded ? `Collapse ${node.name}` : `Expand ${node.name}`}
+          aria-expanded={expanded}
+          data-open={expanded ? "true" : "false"}
+          onclick={() => toggle(node.tag)}
+        >
+          <ChevronRightIcon aria-hidden="true" />
+        </button>
+      {:else}
+        <span class="docs-tags__spacer" aria-hidden="true"></span>
+      {/if}
+      <button
+        type="button"
+        class="docs-sidebar__row"
+        aria-pressed={isSelected(node.tag)}
+        title={`#${node.tag}`}
+        onclick={() => selectTag(node.tag)}
+      >
+        <HashIcon class="docs-sidebar__hash" aria-hidden="true" />
+        <span class="docs-sidebar__label">{node.name}</span>
+        <span class="docs-sidebar__count">{node.count}</span>
+      </button>
+    </div>
+    {#if expanded}
+      <div class="docs-sidebar__group">
+        {#each node.children as child (child.tag)}
+          {@render tagNode(child, depth + 1)}
+        {/each}
+      </div>
+    {/if}
+  </div>
+{/snippet}

package/dist/docs/sidebar/DocsTagsSidebar.svelte.d.ts

@@ -0,0 +1,12 @@
+import type { DocsTagSummary } from "../../model";
+import type { DocsTagsViewMode } from "./docs-sidebar-ui-storage";
+type $$ComponentProps = {
+    tags?: DocsTagSummary[];
+    selectedTags?: string[];
+    viewMode?: DocsTagsViewMode;
+    openNodes?: Record<string, boolean>;
+    onSelectTag?: (tag: string) => void;
+};
+declare const DocsTagsSidebar: import("svelte").Component<$$ComponentProps, {}, "openNodes" | "viewMode">;
+type DocsTagsSidebar = ReturnType<typeof DocsTagsSidebar>;
+export default DocsTagsSidebar;

package/dist/docs/sidebar/docs-book-note-tree.d.ts

@@ -0,0 +1,23 @@
+import type { DocsBookNavigation, DocsNoteSummary } from '../../model';
+import { type DocsNoteSortMode } from './docs-note-sort';
+export type DocsBookNoteTreeStandalone = {
+    kind: 'standalone';
+    note: DocsNoteSummary;
+};
+export type DocsBookNoteTreeBook = {
+    kind: 'book';
+    book: DocsBookNavigation;
+    /** Present when the index note is in the filtered set; otherwise null. */
+    indexNote: DocsNoteSummary | null;
+    chapters: DocsNoteSummary[];
+};
+export type DocsBookNoteTreeEntry = DocsBookNoteTreeStandalone | DocsBookNoteTreeBook;
+/**
+ * Nest filtered notes under books using workspace.books TOC membership.
+ * Chapter notes listed in any book are omitted from the top level.
+ *
+ * Without `strict`, a visible book keeps its full chapter TOC, including
+ * unresolved entries. With `strict`, only notes that passed the sidebar
+ * filter are listed.
+ */
+export declare function createDocsBookNoteTree(filteredNotes: DocsNoteSummary[], books: DocsBookNavigation[], sortMode?: DocsNoteSortMode, strict?: boolean): DocsBookNoteTreeEntry[];

package/dist/docs/sidebar/docs-book-note-tree.js

@@ -0,0 +1,88 @@
+import { DEFAULT_DOCS_NOTE_SORT, compareDocsNotes } from './docs-note-sort';
+function compareText(left, right) {
+    return left.localeCompare(right, undefined, { sensitivity: 'base' });
+}
+function entrySortNote(entry) {
+    if (entry.kind === 'standalone')
+        return entry.note;
+    return entry.indexNote;
+}
+function entrySortTitle(entry) {
+    if (entry.kind === 'standalone')
+        return entry.note.title;
+    return entry.indexNote?.title ?? entry.book.title;
+}
+function entrySortId(entry) {
+    if (entry.kind === 'standalone')
+        return entry.note.id;
+    return entry.book.indexNoteId;
+}
+function compareEntries(left, right, mode) {
+    const leftNote = entrySortNote(left);
+    const rightNote = entrySortNote(right);
+    if (leftNote && rightNote)
+        return compareDocsNotes(leftNote, rightNote, mode);
+    return compareText(entrySortTitle(left), entrySortTitle(right)) || compareText(entrySortId(left), entrySortId(right));
+}
+function summaryFromBookChapter(chapter) {
+    return {
+        id: chapter.noteId,
+        title: chapter.title || chapter.noteId,
+        docType: 'freeform',
+        summary: chapter.summary ?? '',
+        aliases: [],
+        tags: [],
+        sourcePath: chapter.sourcePath || `docs/${chapter.noteId}.doc.md`,
+        createdAt: chapter.completedAt ?? '',
+        updatedAt: chapter.completedAt ?? '',
+        cardCount: 0,
+        blockCount: 0,
+        ...(chapter.completedAt ? { completedAt: chapter.completedAt } : {})
+    };
+}
+/**
+ * Nest filtered notes under books using workspace.books TOC membership.
+ * Chapter notes listed in any book are omitted from the top level.
+ *
+ * Without `strict`, a visible book keeps its full chapter TOC, including
+ * unresolved entries. With `strict`, only notes that passed the sidebar
+ * filter are listed.
+ */
+export function createDocsBookNoteTree(filteredNotes, books, sortMode = DEFAULT_DOCS_NOTE_SORT, strict = false) {
+    const filteredById = new Map(filteredNotes.map((note) => [note.id, note]));
+    const chapterNoteIds = new Set();
+    const indexNoteIds = new Set();
+    for (const book of books) {
+        indexNoteIds.add(book.indexNoteId);
+        for (const chapter of book.chapters) {
+            chapterNoteIds.add(chapter.noteId);
+        }
+    }
+    const entries = [];
+    for (const book of books) {
+        const indexNote = filteredById.get(book.indexNoteId) ?? null;
+        const chapters = strict
+            ? book.chapters.flatMap((chapter) => {
+                const note = filteredById.get(chapter.noteId);
+                return note ? [note] : [];
+            })
+            : book.chapters.map((chapter) => filteredById.get(chapter.noteId) ?? summaryFromBookChapter(chapter));
+        if (!indexNote && chapters.length === 0)
+            continue;
+        if (!strict && !indexNote && !book.chapters.some((chapter) => filteredById.has(chapter.noteId))) {
+            continue;
+        }
+        entries.push({
+            kind: 'book',
+            book,
+            indexNote,
+            chapters
+        });
+    }
+    for (const note of filteredNotes) {
+        if (indexNoteIds.has(note.id) || chapterNoteIds.has(note.id))
+            continue;
+        entries.push({ kind: 'standalone', note });
+    }
+    return entries.sort((left, right) => compareEntries(left, right, sortMode));
+}

package/dist/docs/sidebar/docs-note-sort.d.ts

@@ -0,0 +1,26 @@
+import type { DocsNoteSummary } from '../../model';
+export type DocsNoteSortMode = 'title-asc' | 'title-desc' | 'updated-desc' | 'updated-asc' | 'created-desc' | 'created-asc';
+export declare const DOCS_NOTE_SORT_OPTIONS: readonly [{
+    readonly value: "title-asc";
+    readonly label: "File Name (A to Z)";
+}, {
+    readonly value: "title-desc";
+    readonly label: "File Name (Z to A)";
+}, {
+    readonly value: "updated-desc";
+    readonly label: "Modified time (new to old)";
+}, {
+    readonly value: "updated-asc";
+    readonly label: "Modified time (old to new)";
+}, {
+    readonly value: "created-desc";
+    readonly label: "Created time (new to old)";
+}, {
+    readonly value: "created-asc";
+    readonly label: "Created time (old to new)";
+}];
+export declare const DEFAULT_DOCS_NOTE_SORT: DocsNoteSortMode;
+export declare function isDocsNoteSortMode(value: unknown): value is DocsNoteSortMode;
+export declare function docsNoteSortLabel(mode: DocsNoteSortMode): "File Name (A to Z)" | "File Name (Z to A)" | "Modified time (new to old)" | "Modified time (old to new)" | "Created time (new to old)" | "Created time (old to new)";
+export declare function compareDocsNotes(left: DocsNoteSummary, right: DocsNoteSummary, mode: DocsNoteSortMode): number;
+export declare function sortDocsNotes(notes: DocsNoteSummary[], mode?: DocsNoteSortMode): DocsNoteSummary[];

package/dist/docs/sidebar/docs-note-sort.js

@@ -0,0 +1,54 @@
+export const DOCS_NOTE_SORT_OPTIONS = [
+    { value: 'title-asc', label: 'File Name (A to Z)' },
+    { value: 'title-desc', label: 'File Name (Z to A)' },
+    { value: 'updated-desc', label: 'Modified time (new to old)' },
+    { value: 'updated-asc', label: 'Modified time (old to new)' },
+    { value: 'created-desc', label: 'Created time (new to old)' },
+    { value: 'created-asc', label: 'Created time (old to new)' }
+];
+export const DEFAULT_DOCS_NOTE_SORT = 'title-asc';
+export function isDocsNoteSortMode(value) {
+    return DOCS_NOTE_SORT_OPTIONS.some((option) => option.value === value);
+}
+export function docsNoteSortLabel(mode) {
+    return (DOCS_NOTE_SORT_OPTIONS.find((option) => option.value === mode)?.label ??
+        DOCS_NOTE_SORT_OPTIONS[0].label);
+}
+function compareText(left, right) {
+    return left.localeCompare(right, undefined, { sensitivity: 'base' });
+}
+function compareTime(left, right) {
+    const leftTime = Date.parse(left);
+    const rightTime = Date.parse(right);
+    const safeLeft = Number.isFinite(leftTime) ? leftTime : 0;
+    const safeRight = Number.isFinite(rightTime) ? rightTime : 0;
+    return safeLeft - safeRight;
+}
+export function compareDocsNotes(left, right, mode) {
+    switch (mode) {
+        case 'title-desc':
+            return compareText(right.title, left.title) || compareText(left.id, right.id);
+        case 'updated-desc':
+            return (compareTime(right.updatedAt, left.updatedAt) ||
+                compareText(left.title, right.title) ||
+                compareText(left.id, right.id));
+        case 'updated-asc':
+            return (compareTime(left.updatedAt, right.updatedAt) ||
+                compareText(left.title, right.title) ||
+                compareText(left.id, right.id));
+        case 'created-desc':
+            return (compareTime(right.createdAt, left.createdAt) ||
+                compareText(left.title, right.title) ||
+                compareText(left.id, right.id));
+        case 'created-asc':
+            return (compareTime(left.createdAt, right.createdAt) ||
+                compareText(left.title, right.title) ||
+                compareText(left.id, right.id));
+        case 'title-asc':
+        default:
+            return compareText(left.title, right.title) || compareText(left.id, right.id);
+    }
+}
+export function sortDocsNotes(notes, mode = DEFAULT_DOCS_NOTE_SORT) {
+    return [...notes].sort((left, right) => compareDocsNotes(left, right, mode));
+}

package/dist/docs/sidebar/docs-sidebar-filters.d.ts

@@ -0,0 +1,17 @@
+import { type DocsBacklink, type DocsNoteSummary, type DocsTagSummary, type DocsWikiLink } from "../../model";
+export type DocsSidebarNoteFilters = {
+    query?: string;
+    dueOnly?: boolean;
+    reviewAll?: boolean;
+    selectedTags?: readonly string[];
+    dueNoteIds?: ReadonlySet<string>;
+};
+/** A note has a review when it is in the due review queue. */
+export declare function docsNoteHasReview(note: Pick<DocsNoteSummary, "id" | "dueCardCount">, dueNoteIds: ReadonlySet<string>): boolean;
+export declare function docsSidebarFiltersActive(filters: DocsSidebarNoteFilters): boolean;
+export declare function filterDocsSidebarNotes(notes: readonly DocsNoteSummary[], filters: DocsSidebarNoteFilters): DocsNoteSummary[];
+/** Tags that appear on the supplied notes, including hierarchy prefixes. */
+export declare function docsTagSummariesForNotes(notes: readonly DocsNoteSummary[]): DocsTagSummary[];
+export declare function filterDocsSidebarBacklinks(links: readonly DocsBacklink[], visibleNoteIds: ReadonlySet<string>, filtering: boolean): DocsBacklink[];
+export declare function filterDocsSidebarOutgoingLinks(links: readonly DocsWikiLink[], visibleNoteIds: ReadonlySet<string>, filtering: boolean): DocsWikiLink[];
+export declare function filterDocsSidebarAmbiguousLinks(links: readonly DocsWikiLink[], visibleNoteIds: ReadonlySet<string>, filtering: boolean): DocsWikiLink[];

package/dist/docs/sidebar/docs-sidebar-filters.js

@@ -0,0 +1,74 @@
+import { docsNoteMatchesTagFolder, docsNoteTagValues, normalizeDocsTag, } from "../../model";
+/** A note has a review when it is in the due review queue. */
+export function docsNoteHasReview(note, dueNoteIds) {
+    return dueNoteIds.has(note.id) || (note.dueCardCount ?? 0) > 0;
+}
+export function docsSidebarFiltersActive(filters) {
+    return Boolean(filters.query?.trim() ||
+        filters.dueOnly ||
+        filters.reviewAll ||
+        filters.selectedTags?.length);
+}
+export function filterDocsSidebarNotes(notes, filters) {
+    const dueNoteIds = filters.dueNoteIds ?? new Set();
+    const selectedTags = filters.selectedTags ?? [];
+    const needle = filters.query?.trim().toLowerCase() ?? "";
+    return notes.filter((note) => {
+        if (filters.dueOnly && !docsNoteHasReview(note, dueNoteIds))
+            return false;
+        if (filters.reviewAll && !docsNoteHasReview(note, dueNoteIds))
+            return false;
+        if (selectedTags.length &&
+            !selectedTags.every((tag) => docsNoteMatchesTagFolder(note, tag))) {
+            return false;
+        }
+        if (!needle)
+            return true;
+        return [note.title, note.id, note.summary, ...note.tags, ...note.aliases]
+            .join(" ")
+            .toLowerCase()
+            .includes(needle);
+    });
+}
+/** Tags that appear on the supplied notes, including hierarchy prefixes. */
+export function docsTagSummariesForNotes(notes) {
+    const byTag = new Map();
+    for (const note of notes) {
+        for (const tag of docsNoteTagValues(note)) {
+            for (const prefix of tagPrefixes(tag)) {
+                const ids = byTag.get(prefix) ?? new Set();
+                ids.add(note.id);
+                byTag.set(prefix, ids);
+            }
+        }
+    }
+    return [...byTag.entries()]
+        .map(([tag, ids]) => ({
+        tag,
+        noteCount: ids.size,
+        cardCount: 0,
+    }))
+        .sort((left, right) => left.tag.localeCompare(right.tag));
+}
+export function filterDocsSidebarBacklinks(links, visibleNoteIds, filtering) {
+    if (!filtering)
+        return [...links];
+    return links.filter((link) => visibleNoteIds.has(link.sourceNoteId));
+}
+export function filterDocsSidebarOutgoingLinks(links, visibleNoteIds, filtering) {
+    if (!filtering)
+        return [...links];
+    return links.filter((link) => Boolean(link.resolvedNoteId) && visibleNoteIds.has(link.resolvedNoteId ?? ""));
+}
+export function filterDocsSidebarAmbiguousLinks(links, visibleNoteIds, filtering) {
+    if (!filtering)
+        return [...links];
+    return links.filter((link) => visibleNoteIds.has(link.sourceNoteId));
+}
+function tagPrefixes(tag) {
+    const parts = normalizeDocsTag(tag)
+        .split("/")
+        .map((part) => part.trim())
+        .filter(Boolean);
+    return parts.map((_, index) => parts.slice(0, index + 1).join("/"));
+}

package/dist/docs/sidebar/docs-sidebar-ui-storage.d.ts

@@ -0,0 +1,24 @@
+import { type DocsNoteSortMode } from './docs-note-sort';
+export declare const DOCS_SIDEBAR_UI_STORAGE_KEY = "lapis:docs:sidebar-ui:v1";
+export type DocsSidebarView = 'docs' | 'folders' | 'links' | 'tags';
+export type DocsTagsViewMode = 'tree' | 'flat';
+export type DocsFolderDisplayMode = 'panel' | 'inline';
+export type { DocsNoteSortMode };
+export type DocsSidebarUiState = {
+    sidebarView: DocsSidebarView;
+    folderMode: boolean;
+    folderFollowActive: boolean;
+    folderDisplayMode: DocsFolderDisplayMode;
+    sourceFolderFollowActive: boolean;
+    sourceFolderOpenNodes: Record<string, boolean>;
+    tagsViewMode: DocsTagsViewMode;
+    folderOpenNodes: Record<string, boolean>;
+    tagsOpenNodes: Record<string, boolean>;
+    bookOpenNodes: Record<string, boolean>;
+    notesFollowActive: boolean;
+    notesFiltersOpen: boolean;
+    noteSortMode: DocsNoteSortMode;
+};
+export declare const DEFAULT_DOCS_SIDEBAR_UI_STATE: DocsSidebarUiState;
+export declare function readDocsSidebarUiState(): DocsSidebarUiState;
+export declare function writeDocsSidebarUiState(state: DocsSidebarUiState): void;

package/dist/docs/sidebar/docs-sidebar-ui-storage.js

@@ -0,0 +1,87 @@
+import { DEFAULT_DOCS_NOTE_SORT, isDocsNoteSortMode } from './docs-note-sort';
+export const DOCS_SIDEBAR_UI_STORAGE_KEY = 'lapis:docs:sidebar-ui:v1';
+export const DEFAULT_DOCS_SIDEBAR_UI_STATE = {
+    sidebarView: 'docs',
+    folderMode: false,
+    folderFollowActive: true,
+    folderDisplayMode: 'panel',
+    sourceFolderFollowActive: true,
+    sourceFolderOpenNodes: {},
+    tagsViewMode: 'tree',
+    folderOpenNodes: {},
+    tagsOpenNodes: {},
+    bookOpenNodes: {},
+    notesFollowActive: true,
+    notesFiltersOpen: false,
+    noteSortMode: DEFAULT_DOCS_NOTE_SORT
+};
+function isSidebarView(value) {
+    return value === 'docs' || value === 'folders' || value === 'links' || value === 'tags';
+}
+function isTagsViewMode(value) {
+    return value === 'tree' || value === 'flat';
+}
+function isFolderDisplayMode(value) {
+    return value === 'panel' || value === 'inline';
+}
+function isBooleanRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    return Object.values(value).every((item) => typeof item === 'boolean');
+}
+export function readDocsSidebarUiState() {
+    if (typeof localStorage === 'undefined') {
+        return {
+            ...DEFAULT_DOCS_SIDEBAR_UI_STATE,
+            folderOpenNodes: {},
+            tagsOpenNodes: {},
+            bookOpenNodes: {}
+        };
+    }
+    try {
+        const rawValue = localStorage.getItem(DOCS_SIDEBAR_UI_STORAGE_KEY);
+        if (!rawValue) {
+            return {
+                ...DEFAULT_DOCS_SIDEBAR_UI_STATE,
+                folderOpenNodes: {},
+                tagsOpenNodes: {},
+                bookOpenNodes: {}
+            };
+        }
+        const parsed = JSON.parse(rawValue);
+        return {
+            sidebarView: isSidebarView(parsed.sidebarView) ? parsed.sidebarView : 'docs',
+            folderMode: parsed.folderMode === true,
+            folderFollowActive: parsed.folderFollowActive !== false,
+            folderDisplayMode: isFolderDisplayMode(parsed.folderDisplayMode)
+                ? parsed.folderDisplayMode
+                : 'panel',
+            sourceFolderFollowActive: parsed.sourceFolderFollowActive !== false,
+            sourceFolderOpenNodes: isBooleanRecord(parsed.sourceFolderOpenNodes)
+                ? { ...parsed.sourceFolderOpenNodes }
+                : {},
+            tagsViewMode: isTagsViewMode(parsed.tagsViewMode) ? parsed.tagsViewMode : 'tree',
+            folderOpenNodes: isBooleanRecord(parsed.folderOpenNodes) ? { ...parsed.folderOpenNodes } : {},
+            tagsOpenNodes: isBooleanRecord(parsed.tagsOpenNodes) ? { ...parsed.tagsOpenNodes } : {},
+            bookOpenNodes: isBooleanRecord(parsed.bookOpenNodes) ? { ...parsed.bookOpenNodes } : {},
+            notesFollowActive: parsed.notesFollowActive !== false,
+            notesFiltersOpen: parsed.notesFiltersOpen === true,
+            noteSortMode: isDocsNoteSortMode(parsed.noteSortMode)
+                ? parsed.noteSortMode
+                : DEFAULT_DOCS_NOTE_SORT
+        };
+    }
+    catch {
+        return {
+            ...DEFAULT_DOCS_SIDEBAR_UI_STATE,
+            folderOpenNodes: {},
+            tagsOpenNodes: {},
+            bookOpenNodes: {}
+        };
+    }
+}
+export function writeDocsSidebarUiState(state) {
+    if (typeof localStorage === 'undefined')
+        return;
+    localStorage.setItem(DOCS_SIDEBAR_UI_STORAGE_KEY, JSON.stringify(state));
+}

package/dist/docs/sidebar/docs-source-folder-tree.d.ts

@@ -0,0 +1,16 @@
+import type { DocsNoteSummary } from '../../model';
+import { type DocsNoteSortMode } from './docs-note-sort';
+export declare const DOCS_SOURCE_ROOT_ID = "__docs-root__";
+export type DocsSourceFolderTreeNode = {
+    id: string;
+    path: string;
+    label: string;
+    count: number;
+    isBook: boolean;
+    notes: DocsNoteSummary[];
+    children: DocsSourceFolderTreeNode[];
+};
+export declare function createDocsSourceFolderTree(notes: DocsNoteSummary[], sortMode?: DocsNoteSortMode): DocsSourceFolderTreeNode;
+export declare function filterDocsSourceFolderTree(tree: DocsSourceFolderTreeNode, query: string, sortMode?: DocsNoteSortMode): DocsSourceFolderTreeNode | null;
+export declare function collectExpandableSourceFolderIds(node: DocsSourceFolderTreeNode): string[];
+export declare function sourceFolderAncestorIds(note: Pick<DocsNoteSummary, 'id' | 'sourcePath'>): string[];