@lapis-notes/graph 0.1.0

package/dist/graph-file-preview.svelte.d.ts

@@ -0,0 +1,12 @@
+import { type App } from "@lapis-notes/api";
+import type { GraphNodePreview } from "./graph-renderer";
+type $$ComponentProps = {
+    app: App;
+    preview: GraphNodePreview | null;
+    closeDelayMs: number;
+    onOpenFile: (preview: GraphNodePreview, event: MouseEvent) => void;
+    onDismiss: () => void;
+};
+declare const GraphFilePreview: import("svelte").Component<$$ComponentProps, {}, "">;
+type GraphFilePreview = ReturnType<typeof GraphFilePreview>;
+export default GraphFilePreview;

package/dist/graph-hover-intent.d.ts

@@ -0,0 +1,22 @@
+export interface GraphHoverDelaySettings {
+    activationDelayMs: number;
+    releaseDelayMs: number;
+}
+/** Separates immediate pointer hover from delayed graph emphasis. */
+export declare class GraphHoverIntent {
+    private readonly getDelays;
+    private readonly onEmphasisChange;
+    private activationTimer;
+    private releaseTimer;
+    private pointerNodeId;
+    private emphasisNodeId;
+    constructor(getDelays: () => GraphHoverDelaySettings, onEmphasisChange: (nodeId: string | null) => void);
+    setPointerNode(nodeId: string | null): void;
+    clear(): void;
+    destroy(): void;
+    private activate;
+    private scheduleRelease;
+    private setEmphasisNode;
+    private clearActivationTimer;
+    private clearReleaseTimer;
+}

package/dist/graph-hover-intent.js

@@ -0,0 +1,85 @@
+function normalizedDelay(value) {
+    return Math.max(0, Number.isFinite(value) ? value : 0);
+}
+/** Separates immediate pointer hover from delayed graph emphasis. */
+export class GraphHoverIntent {
+    getDelays;
+    onEmphasisChange;
+    activationTimer = null;
+    releaseTimer = null;
+    pointerNodeId = null;
+    emphasisNodeId = null;
+    constructor(getDelays, onEmphasisChange) {
+        this.getDelays = getDelays;
+        this.onEmphasisChange = onEmphasisChange;
+    }
+    setPointerNode(nodeId) {
+        this.pointerNodeId = nodeId;
+        this.clearActivationTimer();
+        if (nodeId === this.emphasisNodeId) {
+            this.clearReleaseTimer();
+            return;
+        }
+        if (this.emphasisNodeId !== null) {
+            this.scheduleRelease();
+        }
+        if (nodeId !== null) {
+            const delay = normalizedDelay(this.getDelays().activationDelayMs);
+            if (delay === 0) {
+                this.activate(nodeId);
+            }
+            else {
+                this.activationTimer = setTimeout(() => {
+                    this.activationTimer = null;
+                    if (this.pointerNodeId === nodeId)
+                        this.activate(nodeId);
+                }, delay);
+            }
+        }
+    }
+    clear() {
+        this.pointerNodeId = null;
+        this.clearActivationTimer();
+        this.clearReleaseTimer();
+        this.setEmphasisNode(null);
+    }
+    destroy() {
+        this.clear();
+    }
+    activate(nodeId) {
+        this.clearReleaseTimer();
+        this.setEmphasisNode(nodeId);
+    }
+    scheduleRelease() {
+        this.clearReleaseTimer();
+        const source = this.emphasisNodeId;
+        if (source === null)
+            return;
+        const delay = normalizedDelay(this.getDelays().releaseDelayMs);
+        if (delay === 0) {
+            this.setEmphasisNode(null);
+            return;
+        }
+        this.releaseTimer = setTimeout(() => {
+            this.releaseTimer = null;
+            if (this.emphasisNodeId === source)
+                this.setEmphasisNode(null);
+        }, delay);
+    }
+    setEmphasisNode(nodeId) {
+        if (nodeId === this.emphasisNodeId)
+            return;
+        this.emphasisNodeId = nodeId;
+        this.onEmphasisChange(nodeId);
+    }
+    clearActivationTimer() {
+        if (this.activationTimer !== null)
+            clearTimeout(this.activationTimer);
+        this.activationTimer = null;
+    }
+    clearReleaseTimer() {
+        if (this.releaseTimer !== null)
+            clearTimeout(this.releaseTimer);
+        this.releaseTimer = null;
+    }
+}

package/dist/graph-load-alignment.d.ts

@@ -0,0 +1,2 @@
+import type { GraphData } from "./graph-types";
+export declare function graphLoadFocusNodeId(isLocal: boolean, graph: Pick<GraphData, "centerNodeId">): string | null;

package/dist/graph-load-alignment.js

@@ -0,0 +1,3 @@
+export function graphLoadFocusNodeId(isLocal, graph) {
+    return isLocal ? (graph.centerNodeId ?? null) : null;
+}

package/dist/graph-navigation.d.ts

@@ -0,0 +1,7 @@
+import type { Workspace, WorkspaceLeaf } from "@lapis-notes/api";
+export declare function resolveGraphNavigationLeaf(options: {
+    workspace: Workspace;
+    graphLeaf: WorkspaceLeaf;
+    isLocal: boolean;
+    openInNewPane: boolean;
+}): WorkspaceLeaf;

package/dist/graph-navigation.js

@@ -0,0 +1,78 @@
+const GRAPH_VIEW_TYPE = "graph";
+const LOCAL_GRAPH_VIEW_TYPE = "graph-local";
+const GRAPH_VIEW_TYPES = new Set([
+    GRAPH_VIEW_TYPE,
+    LOCAL_GRAPH_VIEW_TYPE,
+    "empty",
+]);
+function isRootLeaf(workspace, leaf) {
+    return Boolean(workspace.rootSplit.iterateAllLeaves((candidate) => (candidate === leaf ? leaf : undefined)));
+}
+function viewTypeForLeaf(leaf) {
+    const view = leaf.view;
+    if (view && typeof view.getViewType === "function") {
+        return view.getViewType();
+    }
+    return typeof leaf.state?.type === "string" ? leaf.state.type : "";
+}
+function isGraphLikeViewType(viewType) {
+    return GRAPH_VIEW_TYPES.has(viewType);
+}
+function isDocumentNavigationLeaf(leaf, graphLeaf) {
+    if (leaf === graphLeaf) {
+        return false;
+    }
+    const viewType = viewTypeForLeaf(leaf);
+    if (isGraphLikeViewType(viewType)) {
+        return false;
+    }
+    const filePath = leaf.state?.state?.["file"];
+    if (typeof filePath === "string" && filePath.length > 0) {
+        return true;
+    }
+    const view = leaf.view;
+    if (view && typeof view === "object" && "file" in view) {
+        const file = view.file;
+        return typeof file?.path === "string" && file.path.length > 0;
+    }
+    return viewType.length > 0 && !isGraphLikeViewType(viewType);
+}
+function findRootDocumentLeaf(workspace, graphLeaf) {
+    const selectedInTab = workspace.rootSplit.iterateAllTabs((tabs) => {
+        const leaf = tabs.selectedLeaf;
+        if (leaf && isDocumentNavigationLeaf(leaf, graphLeaf)) {
+            return leaf;
+        }
+        return undefined;
+    });
+    if (selectedInTab) {
+        return selectedInTab;
+    }
+    let fallback = null;
+    workspace.rootSplit.iterateAllLeaves((leaf) => {
+        if (isDocumentNavigationLeaf(leaf, graphLeaf)) {
+            fallback ??= leaf;
+        }
+    });
+    return fallback;
+}
+export function resolveGraphNavigationLeaf(options) {
+    const { workspace, graphLeaf, isLocal, openInNewPane } = options;
+    if (isLocal || !isRootLeaf(workspace, graphLeaf)) {
+        return workspace.getLeaf(openInNewPane ? true : undefined);
+    }
+    const activeRoot = workspace.activeRootLeaf;
+    if (activeRoot &&
+        activeRoot !== graphLeaf &&
+        isDocumentNavigationLeaf(activeRoot, graphLeaf)) {
+        return activeRoot;
+    }
+    const rootDocumentLeaf = findRootDocumentLeaf(workspace, graphLeaf);
+    if (rootDocumentLeaf) {
+        return rootDocumentLeaf;
+    }
+    if (openInNewPane) {
+        return workspace.getLeaf(true);
+    }
+    return graphLeaf;
+}

package/dist/graph-node-activation.d.ts

@@ -0,0 +1,4 @@
+import type { App } from "@lapis-notes/api";
+import type { GraphNode } from "./graph-types";
+export declare function graphTagSearchQuery(node: GraphNode): string | null;
+export declare function openGraphTagSearch(app: Pick<App, "commands">, node: GraphNode): Promise<boolean>;

package/dist/graph-node-activation.js

@@ -0,0 +1,16 @@
+import { normalizeGraphTag } from "./graph-data";
+export function graphTagSearchQuery(node) {
+    if (node.type !== "tag")
+        return null;
+    const tag = normalizeGraphTag(node.label || node.path || "");
+    return tag ? `tag:${tag}` : null;
+}
+export async function openGraphTagSearch(app, node) {
+    const query = graphTagSearchQuery(node);
+    if (query == null)
+        return false;
+    await app.commands
+        .executeCommand("search:open-search", query)
+        .catch(() => undefined);
+    return true;
+}

package/dist/graph-plugin.d.ts

@@ -0,0 +1,38 @@
+import { Plugin, type App, type PluginManifest } from "@lapis-notes/api";
+import { type GraphCoordinatorState } from "./graph-data-coordinator";
+import type { GraphSettings } from "./graph-types";
+import type { GraphData } from "./graph-types";
+import { type GraphQueryMatches } from "./graph-query-resolution";
+import { type GraphProblemScope } from "./graph-problems";
+interface GraphFocusableView {
+    focusActiveFile(): void;
+    applyGraphSettings(settings: GraphSettings): void;
+}
+export declare class GraphPlugin extends Plugin {
+    private readonly views;
+    private readonly graphCoordinator;
+    private settings;
+    private settingsSaveTimer;
+    private pendingSettingsSave;
+    private graphProblems;
+    private readonly pathQueryCache;
+    constructor(app: App, manifest?: PluginManifest);
+    onload(): Promise<void>;
+    onunload(): Promise<void>;
+    getSettings(): GraphSettings;
+    updateSettings(nextSettings: GraphSettings): Promise<void>;
+    subscribeToGlobalGraph(listener: (state: GraphCoordinatorState) => void): () => void;
+    refreshGlobalGraph(force?: boolean): Promise<void>;
+    reportGraphBuildFailure(scope: GraphProblemScope, path: string | null, error: unknown): void;
+    clearGraphBuildFailure(scope: GraphProblemScope): void;
+    resolveGraphSettings(graph: GraphData, settings: GraphSettings): Promise<{
+        graph: GraphData;
+        matches: GraphQueryMatches;
+    }>;
+    registerGraphView(view: GraphFocusableView): () => void;
+    private initializeSettings;
+    private scheduleSettingsSave;
+    private matchSearchPaths;
+    private openGraphView;
+}
+export default GraphPlugin;

package/dist/graph-plugin.js

@@ -0,0 +1,177 @@
+import { Plugin, } from "@lapis-notes/api";
+import { DEFAULT_GRAPH_SETTINGS, loadPersistedGraphSettings, mergeGraphSettings, serializeGraphSettings, } from "./graph-settings";
+import { GraphDataCoordinator, } from "./graph-data-coordinator";
+import { filterGraphBySettings } from "./graph-data";
+import { resolveGraphQueryMatches, } from "./graph-query-resolution";
+import { GraphView, GraphViewType, LocalGraphView, LocalGraphViewType, } from "./graph-view";
+import { createGraphProblemReporter, } from "./graph-problems";
+import manifestSpec from "../../manifest.json";
+export class GraphPlugin extends Plugin {
+    views = new Set();
+    graphCoordinator;
+    settings = mergeGraphSettings(DEFAULT_GRAPH_SETTINGS);
+    settingsSaveTimer = null;
+    pendingSettingsSave = null;
+    graphProblems = null;
+    pathQueryCache = new Map();
+    constructor(app, manifest = manifestSpec) {
+        super(app, manifest);
+        this.graphCoordinator = new GraphDataCoordinator(app);
+    }
+    async onload() {
+        await this.initializeSettings();
+        this.graphProblems = createGraphProblemReporter(this);
+        this.register(this.graphCoordinator.subscribe((state) => {
+            if (state.status === "error") {
+                this.reportGraphBuildFailure("global", null, state.error);
+            }
+            else if (state.status === "ready") {
+                this.clearGraphBuildFailure("global");
+            }
+        }));
+        this.registerView(GraphViewType, (leaf) => new GraphView(leaf, this), {
+            kind: "command",
+            command: {
+                id: "open-graph-view",
+                name: "Open graph view",
+                callback: () => void this.openGraphView(false),
+            },
+        });
+        this.registerSidebarView(LocalGraphViewType, (leaf) => new LocalGraphView(leaf, this), { side: "right", title: "Local graph", icon: "git-branch-plus" }, {
+            kind: "command",
+            command: {
+                id: "open-local-graph",
+                name: "Open local graph",
+                callback: () => void this.openGraphView(true),
+            },
+        });
+        this.addRibbonIcon("waypoints", "Open graph view", () => {
+            void this.openGraphView(false);
+        });
+        this.addCommand({
+            id: "focus-active-file-in-graph",
+            name: "Focus active file in graph",
+            callback: () => {
+                this.views.forEach((view) => view.focusActiveFile());
+            },
+        });
+        this.registerEvent(this.app.metadataCache.on("index-changed", (change) => {
+            if (change.reset ||
+                change.domains.includes("metadata") ||
+                change.domains.includes("search")) {
+                this.pathQueryCache.clear();
+            }
+            if (change.reset || change.domains.includes("metadata")) {
+                void this.graphCoordinator.requestRefresh("metadata-change", true);
+            }
+            else if (change.domains.includes("search")) {
+                const snapshot = this.getSettings();
+                this.views.forEach((view) => view.applyGraphSettings(snapshot));
+            }
+        }));
+        void this.graphCoordinator.start();
+    }
+    async onunload() {
+        this.graphCoordinator.dispose();
+        this.graphProblems = null;
+        if (this.settingsSaveTimer)
+            clearTimeout(this.settingsSaveTimer);
+        this.settingsSaveTimer = null;
+        const pending = this.pendingSettingsSave;
+        this.pendingSettingsSave = null;
+        if (pending)
+            await this.saveData(pending);
+    }
+    getSettings() {
+        return mergeGraphSettings(this.settings);
+    }
+    async updateSettings(nextSettings) {
+        this.settings = mergeGraphSettings(nextSettings);
+        const snapshot = this.getSettings();
+        this.views.forEach((view) => {
+            view.applyGraphSettings(snapshot);
+        });
+        this.scheduleSettingsSave(snapshot);
+    }
+    subscribeToGlobalGraph(listener) {
+        return this.graphCoordinator.subscribe(listener);
+    }
+    refreshGlobalGraph(force = false) {
+        return this.graphCoordinator.requestRefresh("view-refresh", force);
+    }
+    reportGraphBuildFailure(scope, path, error) {
+        this.graphProblems?.report(scope, path, error);
+    }
+    clearGraphBuildFailure(scope) {
+        this.graphProblems?.clear(scope);
+    }
+    async resolveGraphSettings(graph, settings) {
+        const matches = await resolveGraphQueryMatches(settings, (query) => this.matchSearchPaths(query));
+        return {
+            graph: filterGraphBySettings(graph, settings, matches),
+            matches,
+        };
+    }
+    registerGraphView(view) {
+        this.views.add(view);
+        return () => {
+            this.views.delete(view);
+        };
+    }
+    async initializeSettings() {
+        const storedData = await this.loadData();
+        const loaded = loadPersistedGraphSettings(storedData);
+        this.settings = loaded.settings;
+        if (loaded.migrated) {
+            await this.saveData(serializeGraphSettings(this.settings));
+        }
+    }
+    scheduleSettingsSave(settings) {
+        this.pendingSettingsSave = serializeGraphSettings(settings);
+        if (this.settingsSaveTimer)
+            clearTimeout(this.settingsSaveTimer);
+        this.settingsSaveTimer = setTimeout(() => {
+            this.settingsSaveTimer = null;
+            const pending = this.pendingSettingsSave;
+            this.pendingSettingsSave = null;
+            if (pending)
+                void this.saveData(pending);
+        }, 180);
+    }
+    matchSearchPaths(query) {
+        let cached = this.pathQueryCache.get(query);
+        if (!cached) {
+            cached = this.app.appDatabase
+                .searchDocumentPaths(query, { mode: "lexical", limit: 50_000 })
+                .then((paths) => new Set(paths));
+            this.pathQueryCache.set(query, cached);
+            void cached.catch(() => this.pathQueryCache.delete(query));
+        }
+        return cached;
+    }
+    async openGraphView(local) {
+        const viewType = local ? LocalGraphViewType : GraphViewType;
+        const leaves = this.app.workspace.getLeavesOfType(viewType);
+        if (leaves.length) {
+            const leaf = leaves[0];
+            this.app.workspace.activateLeaf(leaf, {
+                focusRootHost: false,
+                source: "api",
+                operation: local ? "open-local-graph" : "open-graph-view",
+            });
+            await this.app.workspace.revealLeaf(leaf);
+            return;
+        }
+        const leaf = local
+            ? this.app.workspace.ensureSideLeaf(viewType, "right")
+            : this.app.workspace.getLeaf(true);
+        await leaf.setViewState({ type: viewType }, { history: true });
+        this.app.workspace.activateLeaf(leaf, {
+            focusRootHost: false,
+            source: "api",
+            operation: local ? "open-local-graph" : "open-graph-view",
+        });
+        await this.app.workspace.revealLeaf(leaf);
+    }
+}
+export default GraphPlugin;

package/dist/graph-problems.d.ts

@@ -0,0 +1,15 @@
+import { type DiagnosticCollection, type DiagnosticCollectionOptions } from "@lapis-notes/api";
+export type GraphProblemScope = "global" | "local";
+interface GraphProblemOwner {
+    createDiagnosticCollection(id: string, options?: DiagnosticCollectionOptions): DiagnosticCollection;
+}
+export declare class GraphProblemReporter {
+    private readonly collection;
+    private readonly problems;
+    constructor(collection: DiagnosticCollection);
+    report(scope: GraphProblemScope, path: string | null, error: unknown): void;
+    clear(scope: GraphProblemScope): void;
+    private publish;
+}
+export declare function createGraphProblemReporter(owner: GraphProblemOwner): GraphProblemReporter;
+export {};

package/dist/graph-problems.js

@@ -0,0 +1,46 @@
+import { diagnosticResourceForPath, } from "@lapis-notes/api";
+function failureMessage(scope, error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return `${scope === "local" ? "Local Graph" : "Graph"} failed: ${detail}`;
+}
+export class GraphProblemReporter {
+    collection;
+    problems = new Map();
+    constructor(collection) {
+        this.collection = collection;
+    }
+    report(scope, path, error) {
+        this.problems.set(scope, {
+            resource: scope === "local" && path ? diagnosticResourceForPath(path) : null,
+            diagnostic: {
+                message: failureMessage(scope, error),
+                severity: "error",
+                source: "Graph",
+                code: `lapis-graph/${scope}-build`,
+            },
+        });
+        this.publish();
+    }
+    clear(scope) {
+        if (!this.problems.delete(scope))
+            return;
+        this.publish();
+    }
+    publish() {
+        this.collection.clear();
+        const grouped = new Map();
+        for (const problem of this.problems.values()) {
+            const key = problem.resource?.uri ?? "workspace";
+            const current = grouped.get(key) ?? {
+                resource: problem.resource,
+                diagnostics: [],
+            };
+            current.diagnostics.push(problem.diagnostic);
+            grouped.set(key, current);
+        }
+        this.collection.set([...grouped.values()].map(({ resource, diagnostics }) => [resource, diagnostics]));
+    }
+}
+export function createGraphProblemReporter(owner) {
+    return new GraphProblemReporter(owner.createDiagnosticCollection("build", { label: "Graph" }));
+}

package/dist/graph-query-resolution.d.ts

@@ -0,0 +1,9 @@
+import type { GraphSettings } from "./graph-types";
+export interface GraphQueryMatches {
+    filterPaths?: ReadonlySet<string>;
+    groupPaths: ReadonlyMap<string, ReadonlySet<string>>;
+    filterDiagnostic: string | null;
+    groupDiagnostics: Readonly<Record<string, string>>;
+}
+export type GraphPathQuery = (query: string) => Promise<ReadonlySet<string>>;
+export declare function resolveGraphQueryMatches(settings: GraphSettings, matchPaths: GraphPathQuery): Promise<GraphQueryMatches>;

package/dist/graph-query-resolution.js

@@ -0,0 +1,44 @@
+import { parseSearchQueryAst } from "@lapis-notes/api";
+function queryDiagnostic(query) {
+    return parseSearchQueryAst(query).diagnostics[0]?.message ?? null;
+}
+export async function resolveGraphQueryMatches(settings, matchPaths) {
+    const groupPaths = new Map();
+    const groupDiagnostics = {};
+    const filterQuery = settings.filters.searchQuery.trim();
+    let filterPaths;
+    let filterDiagnostic = null;
+    if (filterQuery) {
+        filterDiagnostic = queryDiagnostic(filterQuery);
+        if (!filterDiagnostic) {
+            try {
+                filterPaths = await matchPaths(filterQuery);
+            }
+            catch {
+                filterDiagnostic = "Unable to evaluate this filter";
+            }
+        }
+    }
+    await Promise.all(settings.groups.map(async (group) => {
+        const query = group.query.trim();
+        if (!query)
+            return;
+        const diagnostic = queryDiagnostic(query);
+        if (diagnostic) {
+            groupDiagnostics[group.id] = diagnostic;
+            return;
+        }
+        try {
+            groupPaths.set(group.id, await matchPaths(query));
+        }
+        catch {
+            groupDiagnostics[group.id] = "Unable to evaluate this Group";
+        }
+    }));
+    return {
+        filterPaths,
+        groupPaths,
+        filterDiagnostic,
+        groupDiagnostics,
+    };
+}