@lapis-notes/bookmarks 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Bookmarks changelog
+
+## 0.1.0
+
+- Initial independent public package extracted from Lapis Notes without changing
+  the runtime plugin ID.

package/LICENSE.md

@@ -0,0 +1,8 @@
+# License
+
+Copyright (c) LapisMD contributors.
+
+This software is licensed under the GNU Affero General Public License, version
+3 or (at your option) any later version (`AGPL-3.0-or-later`). The complete
+license text is available from the
+[GNU Project](https://www.gnu.org/licenses/agpl-3.0.html).

package/README.md

@@ -0,0 +1,20 @@
+# Bookmarks
+
+Bookmark files, folders, searches, and groups
+
+## Install for static composition
+
+```sh
+pnpm add @lapis-notes/bookmarks
+```
+
+Register the exported plugin class in the application's `PluginProfile`. Import
+`@lapis-notes/bookmarks/styles.css?inline` and pass the CSS through the static
+registration so the host owns its lifecycle.
+
+The runtime plugin ID is `bookmarks`. A matching signed
+`bookmarks-0.1.0.lapis-plugin` archive is attached to the
+package-scoped GitHub release for manual or registry installation.
+
+See the [repository README](https://github.com/lapismd/lapis-plugins#readme) for
+development, validation, and release-gate details.

package/dist/activate-bookmark.d.ts

@@ -0,0 +1,11 @@
+import { type App, type TFile } from "@lapis-notes/api";
+import { type BookmarkItem } from "./bookmarks-schema";
+export declare function isAllowedBookmarkUrl(url: string): boolean;
+export declare function activateBookmark(app: App, item: BookmarkItem, openUrl?: (url: string) => void): Promise<void>;
+export declare function bookmarkableTarget(app: App): {
+    kind: "file";
+    file: TFile;
+} | {
+    kind: "search";
+    query: string;
+} | null;

package/dist/activate-bookmark.js

@@ -0,0 +1,113 @@
+import { Notice, TextFileView, resolveSubpath, } from "@lapis-notes/api";
+import { isFileBookmark, isFolderBookmark, isGraphBookmark, isGroupBookmark, isSearchBookmark, isUrlBookmark, } from "./bookmarks-schema";
+const FILE_EXPLORER_REVEAL_PATH_COMMAND = "lapis-file-explorer:reveal-path";
+const SEARCH_OPEN_COMMAND = "search:open-search";
+const GRAPH_VIEW_TYPE = "graph";
+export function isAllowedBookmarkUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === "http:" || parsed.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+export async function activateBookmark(app, item, openUrl = defaultOpenUrl) {
+    if (isFileBookmark(item)) {
+        await activateFileBookmark(app, item.path, item.subpath);
+        return;
+    }
+    if (isFolderBookmark(item)) {
+        if (!app.vault.getAbstractFileByPath(item.path)) {
+            new Notice(`Unable to find folder: ${item.path || "unknown"}`);
+            return;
+        }
+        await app.commands.executeCommand(FILE_EXPLORER_REVEAL_PATH_COMMAND, item.path);
+        return;
+    }
+    if (isSearchBookmark(item)) {
+        await app.commands.executeCommand(SEARCH_OPEN_COMMAND, item.query);
+        return;
+    }
+    if (isUrlBookmark(item)) {
+        if (!isAllowedBookmarkUrl(item.url)) {
+            new Notice("Only http and https bookmark URLs can be opened.");
+            return;
+        }
+        openUrl(item.url);
+        return;
+    }
+    if (isGraphBookmark(item)) {
+        await activateGraphBookmark(app);
+        return;
+    }
+    if (isGroupBookmark(item))
+        return;
+    new Notice(`Unsupported bookmark type: ${item.type}`);
+}
+async function activateFileBookmark(app, path, subpath) {
+    const file = app.vault.getFileByPath(path);
+    if (!file) {
+        new Notice(`Unable to find file: ${path || "unknown"}`);
+        return;
+    }
+    await app.openFile(file);
+    if (!subpath)
+        return;
+    const cache = app.metadataCache.getFileCache(file);
+    if (!cache)
+        return;
+    const resolved = resolveSubpath(cache, subpath);
+    if (!resolved)
+        return;
+    const view = app.workspace.activeLeaf?.view;
+    if (!(view instanceof TextFileView))
+        return;
+    view.editor.setCursor({
+        line: resolved.start.line,
+        ch: resolved.start.col,
+    });
+}
+async function activateGraphBookmark(app) {
+    const existing = app.workspace.getLeavesOfType(GRAPH_VIEW_TYPE)[0];
+    if (existing) {
+        app.workspace.activateLeaf(existing, {
+            focusRootHost: false,
+            source: "api",
+            operation: "open-graph-bookmark",
+        });
+        await app.workspace.revealLeaf(existing);
+        return;
+    }
+    const leaf = app.workspace.getLeaf();
+    await leaf.setViewState({ type: GRAPH_VIEW_TYPE, state: {} });
+    if (leaf.view.getViewType() === GRAPH_VIEW_TYPE) {
+        app.workspace.activateLeaf(leaf, {
+            focusRootHost: false,
+            source: "api",
+            operation: "open-graph-bookmark",
+        });
+        await app.workspace.revealLeaf(leaf);
+        return;
+    }
+    leaf.detach();
+    new Notice("Graph is not available.");
+}
+function defaultOpenUrl(url) {
+    if (typeof window === "undefined")
+        return;
+    window.open(url, "_blank", "noopener,noreferrer");
+}
+export function bookmarkableTarget(app) {
+    const file = app.workspace.getActiveFile();
+    if (file)
+        return { kind: "file", file };
+    const leaf = app.workspace.activeLeaf;
+    if (leaf?.view.getViewType() === "search") {
+        const query = typeof leaf.view.getState().query === "string"
+            ? String(leaf.view.getState().query)
+            : "";
+        return { kind: "search", query };
+    }
+    return null;
+}

package/dist/add-bookmark-dialog.svelte

@@ -0,0 +1,83 @@
+<script lang="ts">
+  import { Button } from "@lapismd/design-core/shadcn/button";
+  import * as Dialog from "@lapismd/design-core/shadcn/dialog";
+  import { Input } from "@lapismd/design-core/shadcn/input";
+
+  let {
+    open = true,
+    targetLabel,
+    targetValue,
+    titlePlaceholder,
+    targetEditable = false,
+    portalProps,
+    onCancel,
+    onConfirm,
+  }: {
+    open?: boolean;
+    targetLabel: string;
+    targetValue: string;
+    titlePlaceholder: string;
+    targetEditable?: boolean;
+    portalProps: { to: HTMLElement };
+    onCancel: () => void;
+    onConfirm: (title: string, targetValue: string) => void;
+  } = $props();
+
+  let title = $state("");
+  let editedTarget = $state("");
+
+  function submit(): void {
+    const nextTarget = (targetEditable ? editedTarget : targetValue).trim();
+    if (targetEditable && !nextTarget) return;
+    onConfirm(title.trim(), nextTarget);
+  }
+</script>
+
+<Dialog.Root
+  {open}
+  onOpenChange={(next) => {
+    if (!next) onCancel();
+  }}
+>
+  <Dialog.Content {portalProps} class="bookmarks-add-dialog">
+    <Dialog.Header>
+      <Dialog.Title>Add bookmark</Dialog.Title>
+      <Dialog.Description>
+        Optional title defaults to the {targetLabel.toLowerCase()}.
+      </Dialog.Description>
+    </Dialog.Header>
+    <div class="bookmarks-add-dialog__fields">
+      <label class="bookmarks-add-dialog__field">
+        <span>{targetLabel}</span>
+        {#if targetEditable}
+          <Input bind:value={editedTarget} placeholder={titlePlaceholder} />
+        {:else}
+          <Input value={targetValue} readonly />
+        {/if}
+      </label>
+      <label class="bookmarks-add-dialog__field">
+        <span>Title</span>
+        <Input bind:value={title} placeholder={titlePlaceholder} />
+      </label>
+    </div>
+    <Dialog.Footer>
+      <Button variant="outline" onclick={onCancel}>Cancel</Button>
+      <Button onclick={submit}>Continue</Button>
+    </Dialog.Footer>
+  </Dialog.Content>
+</Dialog.Root>
+
+<style>
+  .bookmarks-add-dialog__fields {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+  }
+
+  .bookmarks-add-dialog__field {
+    display: flex;
+    flex-direction: column;
+    gap: 0.35rem;
+    font-size: 0.75rem;
+  }
+</style>

package/dist/add-bookmark-dialog.svelte.d.ts

@@ -0,0 +1,15 @@
+type $$ComponentProps = {
+    open?: boolean;
+    targetLabel: string;
+    targetValue: string;
+    titlePlaceholder: string;
+    targetEditable?: boolean;
+    portalProps: {
+        to: HTMLElement;
+    };
+    onCancel: () => void;
+    onConfirm: (title: string, targetValue: string) => void;
+};
+declare const AddBookmarkDialog: import("svelte").Component<$$ComponentProps, {}, "">;
+type AddBookmarkDialog = ReturnType<typeof AddBookmarkDialog>;
+export default AddBookmarkDialog;

package/dist/bookmarks-filter.d.ts

@@ -0,0 +1,2 @@
+import { type BookmarkItem } from "./bookmarks-schema";
+export declare function filterBookmarkItems(items: BookmarkItem[], query: string): BookmarkItem[];

package/dist/bookmarks-filter.js

@@ -0,0 +1,19 @@
+import { bookmarkSearchText, isGroupBookmark, } from "./bookmarks-schema";
+export function filterBookmarkItems(items, query) {
+    const needle = query.trim().toLocaleLowerCase();
+    if (!needle)
+        return items;
+    const next = [];
+    for (const item of items) {
+        if (isGroupBookmark(item)) {
+            const children = filterBookmarkItems(item.items, query);
+            if (children.length > 0 || bookmarkSearchText(item).includes(needle)) {
+                next.push({ ...item, items: children });
+            }
+            continue;
+        }
+        if (bookmarkSearchText(item).includes(needle))
+            next.push(item);
+    }
+    return next;
+}