@lapis-notes/bookmarks 0.1.0

package/dist/bookmarks-plugin.js

@@ -0,0 +1,170 @@
+import { basename, Notice, Plugin, } from "@lapis-notes/api";
+import AddBookmarkDialog from "./add-bookmark-dialog.svelte";
+import { bookmarkableTarget, isAllowedBookmarkUrl } from "./activate-bookmark";
+import { BookmarksStore, createPluginBookmarksPersistence, createVaultRenameBinding, } from "./bookmarks-store";
+import { BookmarksView } from "./bookmarks-view";
+import { BOOKMARKS_PLUGIN_ID, BookmarksViewType, } from "./bookmarks-view-type";
+import { listBookmarkGroups } from "./bookmarks-schema";
+import { dialogPortalPropsForApp, mountDialog, } from "./mount-dialog";
+import PickBookmarkGroup from "./pick-bookmark-group.svelte";
+import manifestSpec from "../../manifest.json";
+export class BookmarksPlugin extends Plugin {
+    store;
+    constructor(app, manifest = manifestSpec) {
+        super(app, manifest);
+        this.store = new BookmarksStore(createPluginBookmarksPersistence(this));
+    }
+    async onload() {
+        await this.store.load();
+        this.register(createVaultRenameBinding(this.app, this.store));
+        this.registerSidebarView(BookmarksViewType, (leaf) => new BookmarksView(leaf, this), { side: "left", title: "Bookmarks", icon: "bookmark" }, {
+            kind: "command",
+            command: {
+                id: "open-bookmarks",
+                name: "Open Bookmarks",
+                callback: () => void this.openBookmarks(),
+            },
+        });
+        this.addCommand({
+            id: "add-bookmark",
+            name: "Add bookmark",
+            checkCallback: (checking) => {
+                const target = bookmarkableTarget(this.app);
+                if (!target)
+                    return false;
+                if (!checking)
+                    void this.promptAddBookmark();
+                return true;
+            },
+        });
+        this.addCommand({
+            id: "bookmark-url",
+            name: "Bookmark URL",
+            callback: () => void this.promptBookmarkUrl(),
+        });
+    }
+    async openBookmarks() {
+        const existing = this.app.workspace.getLeavesOfType(BookmarksViewType)[0];
+        const target = existing ?? this.app.workspace.ensureSideLeaf(BookmarksViewType, "left");
+        if (!existing) {
+            await target.setViewState({ type: BookmarksViewType, state: {} });
+        }
+        this.app.workspace.activateLeaf(target, {
+            focusRootHost: false,
+            source: "api",
+            operation: "open-bookmarks",
+        });
+        await this.app.workspace.revealLeaf(target);
+    }
+    async createGroup(parentCtime = null) {
+        return this.store.addGroup("Untitled group", parentCtime);
+    }
+    async promptAddBookmark() {
+        const target = bookmarkableTarget(this.app);
+        if (!target) {
+            new Notice("No active file or search to bookmark.");
+            return;
+        }
+        if (target.kind === "file") {
+            await this.promptAdd({
+                kind: "file",
+                targetLabel: "Path",
+                targetValue: target.file.path,
+                titlePlaceholder: target.file.basename || basename(target.file.path),
+            });
+            return;
+        }
+        await this.promptAdd({
+            kind: "search",
+            targetLabel: "Query",
+            targetValue: target.query,
+            titlePlaceholder: target.query || "Search",
+        });
+    }
+    async promptBookmarkUrl() {
+        await this.promptAdd({
+            kind: "url",
+            targetLabel: "URL",
+            targetValue: "",
+            titlePlaceholder: "Example",
+            targetEditable: true,
+        });
+    }
+    async promptAdd(draft) {
+        const confirmed = await new Promise((resolve) => {
+            const host = mountDialog(this.app, AddBookmarkDialog, {
+                targetLabel: draft.targetLabel,
+                targetValue: draft.targetValue,
+                titlePlaceholder: draft.titlePlaceholder,
+                targetEditable: draft.targetEditable ?? false,
+                portalProps: dialogPortalPropsForApp(this.app),
+                onCancel: () => {
+                    host.close();
+                    resolve(null);
+                },
+                onConfirm: (title, targetValue) => {
+                    host.close();
+                    resolve({ title, targetValue });
+                },
+            });
+        });
+        if (!confirmed)
+            return;
+        if (draft.kind === "url" && !isAllowedBookmarkUrl(confirmed.targetValue)) {
+            new Notice("Only http and https bookmark URLs can be opened.");
+            return;
+        }
+        const parentCtime = await this.pickGroup();
+        if (parentCtime === undefined)
+            return;
+        if (draft.kind === "file") {
+            await this.store.addFile(confirmed.targetValue, {
+                title: confirmed.title || undefined,
+                parentCtime,
+            });
+            return;
+        }
+        if (draft.kind === "search") {
+            await this.store.addSearch(confirmed.targetValue, {
+                title: confirmed.title || undefined,
+                parentCtime,
+            });
+            return;
+        }
+        await this.store.addUrl(confirmed.targetValue, {
+            title: confirmed.title || undefined,
+            parentCtime,
+        });
+    }
+    async pickGroup() {
+        const groups = [
+            { ctime: null, label: "Root", description: "Top level" },
+            ...listBookmarkGroups(this.store.items).map(({ item, crumbs }) => ({
+                ctime: item.ctime,
+                label: item.title || crumbs.at(-1) || "Untitled group",
+                description: crumbs.join(" / "),
+            })),
+        ];
+        return new Promise((resolve) => {
+            const host = mountDialog(this.app, PickBookmarkGroup, {
+                groups,
+                portalProps: dialogPortalPropsForApp(this.app),
+                onCancel: () => {
+                    host.close();
+                    resolve(undefined);
+                },
+                onSelect: (ctime, createTitle) => {
+                    host.close();
+                    void (async () => {
+                        if (createTitle) {
+                            const created = await this.store.addGroup(createTitle, ctime);
+                            resolve(created.ctime);
+                            return;
+                        }
+                        resolve(ctime);
+                    })();
+                },
+            });
+        });
+    }
+}

package/dist/bookmarks-schema.d.ts

@@ -0,0 +1,75 @@
+export declare const KNOWN_BOOKMARK_TYPES: readonly ["file", "folder", "group", "search", "url", "graph"];
+export type KnownBookmarkType = (typeof KNOWN_BOOKMARK_TYPES)[number];
+export interface FileBookmarkItem {
+    type: "file";
+    ctime: number;
+    path: string;
+    title?: string;
+    subpath?: string;
+}
+export interface FolderBookmarkItem {
+    type: "folder";
+    ctime: number;
+    path: string;
+    title?: string;
+}
+export interface GroupBookmarkItem {
+    type: "group";
+    ctime: number;
+    title?: string;
+    items: BookmarkItem[];
+}
+export interface SearchBookmarkItem {
+    type: "search";
+    ctime: number;
+    query: string;
+    title?: string;
+}
+export interface UrlBookmarkItem {
+    type: "url";
+    ctime: number;
+    url: string;
+    title?: string;
+}
+export interface GraphBookmarkItem {
+    type: "graph";
+    ctime: number;
+    title?: string;
+}
+export interface UnknownBookmarkItem {
+    type: string;
+    ctime: number;
+    title?: string;
+    [key: string]: unknown;
+}
+export type BookmarkItem = FileBookmarkItem | FolderBookmarkItem | GroupBookmarkItem | SearchBookmarkItem | UrlBookmarkItem | GraphBookmarkItem | UnknownBookmarkItem;
+export interface BookmarksDocument {
+    items: BookmarkItem[];
+}
+export type BookmarkIconName = "file" | "folder" | "search" | "external-link" | "git-fork";
+export declare function isKnownBookmarkType(type: string): type is KnownBookmarkType;
+export declare function isFileBookmark(item: BookmarkItem): item is FileBookmarkItem;
+export declare function isFolderBookmark(item: BookmarkItem): item is FolderBookmarkItem;
+export declare function isGroupBookmark(item: BookmarkItem): item is GroupBookmarkItem;
+export declare function isSearchBookmark(item: BookmarkItem): item is SearchBookmarkItem;
+export declare function isUrlBookmark(item: BookmarkItem): item is UrlBookmarkItem;
+export declare function isGraphBookmark(item: BookmarkItem): item is GraphBookmarkItem;
+export declare function parseBookmarkItem(value: unknown): BookmarkItem;
+export declare function parseBookmarkItems(value: unknown): BookmarkItem[];
+export declare function cloneBookmarkItems(items: BookmarkItem[]): BookmarkItem[];
+export declare function parseBookmarksDocument(value: unknown): BookmarksDocument;
+export declare function serializeBookmarksDocument(document: BookmarksDocument): Record<string, unknown>;
+export declare function bookmarkLabel(item: BookmarkItem): string;
+export declare function bookmarkIcon(item: BookmarkItem): BookmarkIconName | null;
+export declare function bookmarkSearchText(item: BookmarkItem): string;
+export declare function nextBookmarkCtime(items: BookmarkItem[], now?: number): number;
+export declare function walkBookmarkItems(items: BookmarkItem[], visit: (item: BookmarkItem, parent: GroupBookmarkItem | null) => void, parent?: GroupBookmarkItem | null): void;
+export declare function listBookmarkGroups(items: BookmarkItem[], ancestors?: string[]): Array<{
+    item: GroupBookmarkItem;
+    crumbs: string[];
+}>;
+export declare function findBookmarkItem(items: BookmarkItem[], ctime: number): BookmarkItem | null;
+export declare function isDescendantGroup(items: BookmarkItem[], ancestorCtime: number, candidateCtime: number): boolean;
+export declare function removeBookmarkItem(items: BookmarkItem[], ctime: number): BookmarkItem | null;
+export declare function insertBookmarkItem(items: BookmarkItem[], item: BookmarkItem, parentCtime: number | null, index: number): boolean;
+export declare function rewriteBookmarkPaths(items: BookmarkItem[], fromPath: string, toPath: string): boolean;

package/dist/bookmarks-schema.js

@@ -0,0 +1,258 @@
+import { basename } from "@lapis-notes/api";
+export const KNOWN_BOOKMARK_TYPES = [
+    "file",
+    "folder",
+    "group",
+    "search",
+    "url",
+    "graph",
+];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readCtime(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : Date.now();
+}
+function readOptionalString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+export function isKnownBookmarkType(type) {
+    return KNOWN_BOOKMARK_TYPES.includes(type);
+}
+export function isFileBookmark(item) {
+    return item.type === "file";
+}
+export function isFolderBookmark(item) {
+    return item.type === "folder";
+}
+export function isGroupBookmark(item) {
+    return item.type === "group";
+}
+export function isSearchBookmark(item) {
+    return item.type === "search";
+}
+export function isUrlBookmark(item) {
+    return item.type === "url";
+}
+export function isGraphBookmark(item) {
+    return item.type === "graph";
+}
+export function parseBookmarkItem(value) {
+    if (!isRecord(value)) {
+        return { type: "unknown", ctime: Date.now() };
+    }
+    const type = typeof value.type === "string" ? value.type : "unknown";
+    const ctime = readCtime(value.ctime);
+    const title = readOptionalString(value.title);
+    const extras = { ...value };
+    if (type === "file") {
+        return {
+            ...extras,
+            type: "file",
+            ctime,
+            path: typeof value.path === "string" ? value.path : "",
+            ...(title ? { title } : {}),
+            ...(typeof value.subpath === "string" ? { subpath: value.subpath } : {}),
+        };
+    }
+    if (type === "folder") {
+        return {
+            ...extras,
+            type: "folder",
+            ctime,
+            path: typeof value.path === "string" ? value.path : "",
+            ...(title ? { title } : {}),
+        };
+    }
+    if (type === "group") {
+        return {
+            ...extras,
+            type: "group",
+            ctime,
+            items: parseBookmarkItems(value.items),
+            ...(title ? { title } : {}),
+        };
+    }
+    if (type === "search") {
+        return {
+            ...extras,
+            type: "search",
+            ctime,
+            query: typeof value.query === "string" ? value.query : "",
+            ...(title ? { title } : {}),
+        };
+    }
+    if (type === "url") {
+        return {
+            ...extras,
+            type: "url",
+            ctime,
+            url: typeof value.url === "string" ? value.url : "",
+            ...(title ? { title } : {}),
+        };
+    }
+    if (type === "graph") {
+        return {
+            ...extras,
+            type: "graph",
+            ctime,
+            ...(title ? { title } : {}),
+        };
+    }
+    return {
+        ...extras,
+        type,
+        ctime,
+        ...(title ? { title } : {}),
+    };
+}
+export function parseBookmarkItems(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((item) => parseBookmarkItem(item));
+}
+export function cloneBookmarkItems(items) {
+    return parseBookmarkItems(items);
+}
+export function parseBookmarksDocument(value) {
+    if (!isRecord(value))
+        return { items: [] };
+    return { items: parseBookmarkItems(value.items) };
+}
+export function serializeBookmarksDocument(document) {
+    return { items: document.items };
+}
+export function bookmarkLabel(item) {
+    if (item.title) {
+        return isFileBookmark(item) && item.subpath
+            ? `${item.title} ${item.subpath}`
+            : item.title;
+    }
+    if (isFileBookmark(item)) {
+        const name = basename(item.path) || item.path || "Untitled";
+        return item.subpath ? `${name} ${item.subpath}` : name;
+    }
+    if (isFolderBookmark(item)) {
+        return basename(item.path) || item.path || "Untitled folder";
+    }
+    if (isGroupBookmark(item))
+        return item.title || "Untitled group";
+    if (isSearchBookmark(item))
+        return item.query || "Search";
+    if (isUrlBookmark(item))
+        return item.url || "URL";
+    if (isGraphBookmark(item))
+        return "Graph";
+    return item.type;
+}
+export function bookmarkIcon(item) {
+    if (item.type === "group")
+        return null;
+    if (item.type === "file")
+        return "file";
+    if (item.type === "folder")
+        return "folder";
+    if (item.type === "search")
+        return "search";
+    if (item.type === "url")
+        return "external-link";
+    if (item.type === "graph")
+        return "git-fork";
+    return "file";
+}
+export function bookmarkSearchText(item) {
+    const parts = [item.title ?? "", item.type];
+    if ("path" in item && typeof item.path === "string")
+        parts.push(item.path);
+    if ("subpath" in item && typeof item.subpath === "string") {
+        parts.push(item.subpath);
+    }
+    if ("query" in item && typeof item.query === "string")
+        parts.push(item.query);
+    if ("url" in item && typeof item.url === "string")
+        parts.push(item.url);
+    return parts.join(" ").toLocaleLowerCase();
+}
+export function nextBookmarkCtime(items, now = Date.now()) {
+    const used = new Set();
+    walkBookmarkItems(items, (item) => {
+        used.add(item.ctime);
+    });
+    let ctime = now;
+    while (used.has(ctime))
+        ctime += 1;
+    return ctime;
+}
+export function walkBookmarkItems(items, visit, parent = null) {
+    for (const item of items) {
+        visit(item, parent);
+        if (isGroupBookmark(item)) {
+            walkBookmarkItems(item.items, visit, item);
+        }
+    }
+}
+export function listBookmarkGroups(items, ancestors = []) {
+    const groups = [];
+    for (const item of items) {
+        if (!isGroupBookmark(item))
+            continue;
+        const crumbs = [...ancestors, bookmarkLabel(item)];
+        groups.push({ item, crumbs });
+        groups.push(...listBookmarkGroups(item.items, crumbs));
+    }
+    return groups;
+}
+export function findBookmarkItem(items, ctime) {
+    for (const item of items) {
+        if (item.ctime === ctime)
+            return item;
+        if (isGroupBookmark(item)) {
+            const nested = findBookmarkItem(item.items, ctime);
+            if (nested)
+                return nested;
+        }
+    }
+    return null;
+}
+export function isDescendantGroup(items, ancestorCtime, candidateCtime) {
+    const ancestor = findBookmarkItem(items, ancestorCtime);
+    if (!ancestor || !isGroupBookmark(ancestor))
+        return false;
+    return findBookmarkItem(ancestor.items, candidateCtime) !== null;
+}
+export function removeBookmarkItem(items, ctime) {
+    const index = items.findIndex((item) => item.ctime === ctime);
+    if (index >= 0) {
+        return items.splice(index, 1)[0] ?? null;
+    }
+    for (const item of items) {
+        if (isGroupBookmark(item)) {
+            const removed = removeBookmarkItem(item.items, ctime);
+            if (removed)
+                return removed;
+        }
+    }
+    return null;
+}
+export function insertBookmarkItem(items, item, parentCtime, index) {
+    if (parentCtime === null) {
+        items.splice(Math.max(0, Math.min(index, items.length)), 0, item);
+        return true;
+    }
+    const parent = findBookmarkItem(items, parentCtime);
+    if (!parent || !isGroupBookmark(parent))
+        return false;
+    parent.items.splice(Math.max(0, Math.min(index, parent.items.length)), 0, item);
+    return true;
+}
+export function rewriteBookmarkPaths(items, fromPath, toPath) {
+    let changed = false;
+    walkBookmarkItems(items, (item) => {
+        if ((isFileBookmark(item) || isFolderBookmark(item)) &&
+            item.path === fromPath) {
+            item.path = toPath;
+            changed = true;
+        }
+    });
+    return changed;
+}

package/dist/bookmarks-store.d.ts

@@ -0,0 +1,44 @@
+import type { App } from "@lapis-notes/api";
+import { type BookmarkItem, type FileBookmarkItem, type FolderBookmarkItem, type GroupBookmarkItem, type SearchBookmarkItem, type UrlBookmarkItem } from "./bookmarks-schema";
+export interface BookmarksPersistence {
+    load(): Promise<unknown>;
+    save(data: unknown): Promise<void>;
+}
+export declare class BookmarksStore {
+    #private;
+    private readonly persistence;
+    constructor(persistence: BookmarksPersistence);
+    get items(): BookmarkItem[];
+    subscribe(listener: () => void): () => void;
+    load(): Promise<void>;
+    addItem(item: BookmarkItem, parentCtime?: number | null): Promise<BookmarkItem>;
+    addFile(path: string, options?: {
+        title?: string;
+        subpath?: string;
+        parentCtime?: number | null;
+    }): Promise<FileBookmarkItem>;
+    addFolder(path: string, options?: {
+        title?: string;
+        parentCtime?: number | null;
+    }): Promise<FolderBookmarkItem>;
+    addGroup(title?: string, parentCtime?: number | null): Promise<GroupBookmarkItem>;
+    addSearch(query: string, options?: {
+        title?: string;
+        parentCtime?: number | null;
+    }): Promise<SearchBookmarkItem>;
+    addUrl(url: string, options?: {
+        title?: string;
+        parentCtime?: number | null;
+    }): Promise<UrlBookmarkItem>;
+    renameItem(ctime: number, title: string): Promise<void>;
+    removeItem(ctime: number): Promise<void>;
+    moveItem(ctime: number, parentCtime: number | null, index: number): Promise<boolean>;
+    rewritePaths(fromPath: string, toPath: string): Promise<void>;
+    private notify;
+    private persist;
+}
+export declare function createPluginBookmarksPersistence(app: {
+    loadData(): Promise<unknown>;
+    saveData(data: unknown): Promise<void>;
+}): BookmarksPersistence;
+export declare function createVaultRenameBinding(app: App, store: BookmarksStore): () => void;

package/dist/bookmarks-store.js

@@ -0,0 +1,143 @@
+import { findBookmarkItem, insertBookmarkItem, isDescendantGroup, isGroupBookmark, nextBookmarkCtime, parseBookmarksDocument, removeBookmarkItem, rewriteBookmarkPaths, serializeBookmarksDocument, } from "./bookmarks-schema";
+export class BookmarksStore {
+    persistence;
+    #document = { items: [] };
+    #listeners = new Set();
+    constructor(persistence) {
+        this.persistence = persistence;
+    }
+    get items() {
+        return this.#document.items;
+    }
+    subscribe(listener) {
+        this.#listeners.add(listener);
+        return () => this.#listeners.delete(listener);
+    }
+    async load() {
+        this.#document = parseBookmarksDocument(await this.persistence.load());
+        this.notify();
+    }
+    async addItem(item, parentCtime = null) {
+        const created = {
+            ...item,
+            ctime: item.ctime ?? nextBookmarkCtime(this.#document.items),
+        };
+        if (isGroupBookmark(created) && !Array.isArray(created.items)) {
+            created.items = [];
+        }
+        const parent = parentCtime
+            ? findBookmarkItem(this.#document.items, parentCtime)
+            : null;
+        insertBookmarkItem(this.#document.items, created, parentCtime, parentCtime === null
+            ? this.#document.items.length
+            : parent && isGroupBookmark(parent)
+                ? parent.items.length
+                : 0);
+        await this.persist();
+        return created;
+    }
+    async addFile(path, options = {}) {
+        const item = {
+            type: "file",
+            ctime: nextBookmarkCtime(this.#document.items),
+            path,
+            ...(options.title ? { title: options.title } : {}),
+            ...(options.subpath ? { subpath: options.subpath } : {}),
+        };
+        return (await this.addItem(item, options.parentCtime ?? null));
+    }
+    async addFolder(path, options = {}) {
+        const item = {
+            type: "folder",
+            ctime: nextBookmarkCtime(this.#document.items),
+            path,
+            ...(options.title ? { title: options.title } : {}),
+        };
+        return (await this.addItem(item, options.parentCtime ?? null));
+    }
+    async addGroup(title = "Untitled group", parentCtime = null) {
+        const item = {
+            type: "group",
+            ctime: nextBookmarkCtime(this.#document.items),
+            title,
+            items: [],
+        };
+        return (await this.addItem(item, parentCtime));
+    }
+    async addSearch(query, options = {}) {
+        const item = {
+            type: "search",
+            ctime: nextBookmarkCtime(this.#document.items),
+            query,
+            ...(options.title ? { title: options.title } : {}),
+        };
+        return (await this.addItem(item, options.parentCtime ?? null));
+    }
+    async addUrl(url, options = {}) {
+        const item = {
+            type: "url",
+            ctime: nextBookmarkCtime(this.#document.items),
+            url,
+            ...(options.title ? { title: options.title } : {}),
+        };
+        return (await this.addItem(item, options.parentCtime ?? null));
+    }
+    async renameItem(ctime, title) {
+        const item = findBookmarkItem(this.#document.items, ctime);
+        if (!item)
+            return;
+        const next = title.trim();
+        if (next)
+            item.title = next;
+        else
+            delete item.title;
+        await this.persist();
+    }
+    async removeItem(ctime) {
+        removeBookmarkItem(this.#document.items, ctime);
+        await this.persist();
+    }
+    async moveItem(ctime, parentCtime, index) {
+        if (parentCtime === ctime)
+            return false;
+        if (parentCtime !== null &&
+            isDescendantGroup(this.#document.items, ctime, parentCtime)) {
+            return false;
+        }
+        const removed = removeBookmarkItem(this.#document.items, ctime);
+        if (!removed)
+            return false;
+        const inserted = insertBookmarkItem(this.#document.items, removed, parentCtime, index);
+        if (!inserted) {
+            insertBookmarkItem(this.#document.items, removed, null, this.#document.items.length);
+            return false;
+        }
+        await this.persist();
+        return true;
+    }
+    async rewritePaths(fromPath, toPath) {
+        if (!rewriteBookmarkPaths(this.#document.items, fromPath, toPath))
+            return;
+        await this.persist();
+    }
+    notify() {
+        for (const listener of this.#listeners)
+            listener();
+    }
+    async persist() {
+        this.notify();
+        await this.persistence.save(serializeBookmarksDocument(this.#document));
+    }
+}
+export function createPluginBookmarksPersistence(app) {
+    return {
+        load: () => app.loadData(),
+        save: (data) => app.saveData(data),
+    };
+}
+export function createVaultRenameBinding(app, store) {
+    const ref = app.vault.on("rename", (file, oldPath) => {
+        void store.rewritePaths(oldPath, file.path);
+    });
+    return () => app.vault.offref(ref);
+}

package/dist/bookmarks-view-type.d.ts

@@ -0,0 +1,2 @@
+export declare const BookmarksViewType = "bookmarks";
+export declare const BOOKMARKS_PLUGIN_ID = "bookmarks";

package/dist/bookmarks-view-type.js

@@ -0,0 +1,2 @@
+export const BookmarksViewType = "bookmarks";
+export const BOOKMARKS_PLUGIN_ID = "bookmarks";