@lapis-notes/graph 0.1.0

package/dist/graph-settings.d.ts

@@ -0,0 +1,20 @@
+import type { GraphGroupRule, GraphSettings, GraphSettingsPatch } from "./graph-types";
+export declare const DEFAULT_GRAPH_GROUPS: GraphGroupRule[];
+export declare const GRAPH_SETTINGS_VERSION = 2;
+export declare function graphForceSliderToStrength(value: number): number;
+export declare function graphStrengthToForceSlider(value: number): number;
+export declare function graphRepelForceMagnitude(value: number): number;
+export declare const DEFAULT_GRAPH_CENTER_FORCE: number;
+export declare const DEFAULT_GRAPH_SETTINGS: GraphSettings;
+export type PersistedGraphSettings = GraphSettings & {
+    settingsVersion: number;
+};
+export type LoadedGraphSettings = {
+    settings: GraphSettings;
+    migrated: boolean;
+};
+export declare function loadPersistedGraphSettings(stored: unknown): LoadedGraphSettings;
+export declare function serializeGraphSettings(settings: GraphSettings): PersistedGraphSettings;
+export declare function mergeGraphSettings(stored: Partial<GraphSettings> | null | undefined): GraphSettings;
+export declare function patchGraphSettings(current: GraphSettings, patch: GraphSettingsPatch): GraphSettings;
+export declare function moveGraphGroup(groups: GraphGroupRule[], index: number, delta: number): GraphGroupRule[];

package/dist/graph-settings.js

@@ -0,0 +1,125 @@
+export const DEFAULT_GRAPH_GROUPS = [];
+export const GRAPH_SETTINGS_VERSION = 2;
+const GRAPH_FORCE_CURVE_BASE = 0.01;
+export function graphForceSliderToStrength(value) {
+    const slider = Math.min(Math.max(Number.isFinite(value) ? value : 0, 0), 1);
+    return ((Math.pow(GRAPH_FORCE_CURVE_BASE, 1 - slider) - GRAPH_FORCE_CURVE_BASE) /
+        (1 - GRAPH_FORCE_CURVE_BASE));
+}
+export function graphStrengthToForceSlider(value) {
+    const strength = Math.min(Math.max(Number.isFinite(value) ? value : 0, 0), 1);
+    const curved = strength * (1 - GRAPH_FORCE_CURVE_BASE) + GRAPH_FORCE_CURVE_BASE;
+    return 1 - Math.log(curved) / Math.log(GRAPH_FORCE_CURVE_BASE);
+}
+export function graphRepelForceMagnitude(value) {
+    const slider = Math.min(Math.max(Number.isFinite(value) ? value : 0, 0), 20);
+    return Math.max(slider ** 3, 1);
+}
+export const DEFAULT_GRAPH_CENTER_FORCE = graphStrengthToForceSlider(0.1);
+export const DEFAULT_GRAPH_SETTINGS = {
+    filters: {
+        searchQuery: "",
+        showTags: false,
+        showAttachments: false,
+        existingFilesOnly: true,
+        showOrphans: true,
+    },
+    display: {
+        showArrows: false,
+        textFadeThreshold: 0.8,
+        nodeSize: 8,
+        linkThickness: 1,
+        wheelZoomSensitivity: 1,
+        hoverActivationDelayMs: 500,
+        hoverReleaseDelayMs: 350,
+    },
+    forces: {
+        centerForce: DEFAULT_GRAPH_CENTER_FORCE,
+        repelForce: 10,
+        linkForce: 1,
+        linkDistance: 250,
+    },
+    localGraph: {
+        depth: 1,
+    },
+    groups: DEFAULT_GRAPH_GROUPS,
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function loadPersistedGraphSettings(stored) {
+    if (!isRecord(stored)) {
+        return {
+            settings: mergeGraphSettings(null),
+            migrated: false,
+        };
+    }
+    const settings = mergeGraphSettings(stored);
+    if (stored.settingsVersion === undefined) {
+        settings.forces = { ...DEFAULT_GRAPH_SETTINGS.forces };
+        return { settings, migrated: true };
+    }
+    return {
+        settings,
+        migrated: stored.settingsVersion === 1,
+    };
+}
+export function serializeGraphSettings(settings) {
+    return {
+        settingsVersion: GRAPH_SETTINGS_VERSION,
+        ...mergeGraphSettings(settings),
+    };
+}
+export function mergeGraphSettings(stored) {
+    return {
+        filters: {
+            ...DEFAULT_GRAPH_SETTINGS.filters,
+            ...stored?.filters,
+        },
+        display: {
+            ...DEFAULT_GRAPH_SETTINGS.display,
+            ...stored?.display,
+        },
+        forces: {
+            ...DEFAULT_GRAPH_SETTINGS.forces,
+            ...stored?.forces,
+        },
+        localGraph: {
+            ...DEFAULT_GRAPH_SETTINGS.localGraph,
+            ...stored?.localGraph,
+        },
+        groups: stored?.groups?.flatMap((group, index) => {
+            if (!isRecord(group))
+                return [];
+            const id = typeof group.id === "string" ? group.id : `group-${index}`;
+            const query = typeof group.query === "string" ? group.query : "";
+            const color = typeof group.color === "string" ? group.color : "#3b82f6";
+            return [{ id, query, color }];
+        }) ?? [],
+    };
+}
+export function patchGraphSettings(current, patch) {
+    return mergeGraphSettings({
+        ...current,
+        ...patch,
+        filters: { ...current.filters, ...patch.filters },
+        display: { ...current.display, ...patch.display },
+        forces: { ...current.forces, ...patch.forces },
+        localGraph: { ...current.localGraph, ...patch.localGraph },
+        groups: patch.groups ?? current.groups,
+    });
+}
+export function moveGraphGroup(groups, index, delta) {
+    const target = index + delta;
+    if (index < 0 ||
+        index >= groups.length ||
+        target < 0 ||
+        target >= groups.length) {
+        return groups.map((group) => ({ ...group }));
+    }
+    const next = groups.map((group) => ({ ...group }));
+    const [group] = next.splice(index, 1);
+    if (group)
+        next.splice(target, 0, group);
+    return next;
+}

package/dist/graph-types.d.ts

@@ -0,0 +1,74 @@
+import type { TFile } from "@lapis-notes/api";
+export type GraphNodeType = "note" | "unresolved" | "tag" | "attachment";
+export type GraphLinkType = "internal-link" | "embed" | "tag";
+export interface GraphNode {
+    id: string;
+    label: string;
+    path: string | null;
+    type: GraphNodeType;
+    exists: boolean;
+    refCount: number;
+    outgoingCount: number;
+    tags: string[];
+    groupIds: string[];
+    primaryColor?: string;
+    ctime?: number;
+    mtime?: number;
+    extension?: string;
+}
+export interface GraphLink {
+    id: string;
+    source: string;
+    target: string;
+    count: number;
+    type: GraphLinkType;
+    directed: boolean;
+}
+export interface GraphData {
+    nodes: GraphNode[];
+    links: GraphLink[];
+    centerNodeId?: string | null;
+}
+export interface GraphGroupRule {
+    id: string;
+    query: string;
+    color: string;
+}
+export interface GraphSettings {
+    filters: {
+        searchQuery: string;
+        showTags: boolean;
+        showAttachments: boolean;
+        existingFilesOnly: boolean;
+        showOrphans: boolean;
+    };
+    display: {
+        showArrows: boolean;
+        textFadeThreshold: number;
+        nodeSize: number;
+        linkThickness: number;
+        wheelZoomSensitivity: number;
+        hoverActivationDelayMs: number;
+        hoverReleaseDelayMs: number;
+    };
+    forces: {
+        centerForce: number;
+        repelForce: number;
+        linkForce: number;
+        linkDistance: number;
+    };
+    localGraph: {
+        depth: number;
+    };
+    groups: GraphGroupRule[];
+}
+export interface GraphSettingsPatch {
+    filters?: Partial<GraphSettings["filters"]>;
+    display?: Partial<GraphSettings["display"]>;
+    forces?: Partial<GraphSettings["forces"]>;
+    localGraph?: Partial<GraphSettings["localGraph"]>;
+    groups?: GraphGroupRule[];
+}
+export interface GraphSearchAdapter {
+    matchesNode(query: string, node: GraphNode, file?: TFile | null): boolean | Promise<boolean>;
+}

package/dist/graph-types.js

@@ -0,0 +1 @@
+export {};

package/dist/graph-view.d.ts

@@ -0,0 +1,62 @@
+import { ItemView, Menu, type WorkspaceLeaf } from "@lapis-notes/api";
+import type { GraphPlugin } from "./graph-plugin";
+import type { GraphData, GraphSettings } from "./graph-types";
+export declare const GraphViewType = "graph";
+export declare const LocalGraphViewType = "graph-local";
+declare abstract class GraphViewBase extends ItemView {
+    protected readonly plugin: GraphPlugin;
+    protected readonly isLocal: boolean;
+    private renderer;
+    private overlay;
+    private settings;
+    private canonicalGraph;
+    private coordinatorGraphVersion;
+    private unsubscribeCoordinator;
+    private currentGraphPaths;
+    private unregisterView;
+    private readonly buildGeneration;
+    private readonly deriveGeneration;
+    private metadataFacetGeneration;
+    private filterSyntax;
+    private readonly scheduleRebuild;
+    private readonly scheduleDerive;
+    constructor(leaf: WorkspaceLeaf | undefined, plugin: GraphPlugin, isLocal: boolean);
+    protected onOpen(): Promise<void>;
+    protected onClose(): Promise<void>;
+    onload(): void;
+    private scheduleViewportRefreshWhenVisible;
+    onunload(): void;
+    onPaneMenu(menu: Menu): void;
+    focusActiveFile(): void;
+    applyGraphSettings(settings: GraphSettings): void;
+    protected abstract getGraphData(settings: GraphSettings): Promise<GraphData>;
+    private rebuild;
+    private applyCoordinatorState;
+    private deriveGraphFromSettings;
+    private renderGraph;
+    private shouldRebuildForMetadataPaths;
+    private getSurfaceEl;
+    private getStatsText;
+    private refreshFilterSyntaxFromVault;
+    private refreshMetadataFacets;
+    private updateLocalSettings;
+    private resetLocalSettings;
+    private resolveNavigationLeaf;
+    private openNode;
+    private showNodeMenu;
+}
+export declare class GraphView extends GraphViewBase {
+    constructor(leaf: WorkspaceLeaf | undefined, plugin: GraphPlugin);
+    getViewType(): string;
+    getDisplayText(): string;
+    getIcon(): string;
+    protected getGraphData(_settings: GraphSettings): Promise<GraphData>;
+}
+export declare class LocalGraphView extends GraphViewBase {
+    constructor(leaf: WorkspaceLeaf | undefined, plugin: GraphPlugin);
+    getViewType(): string;
+    getDisplayText(): string;
+    getIcon(): string;
+    protected getGraphData(settings: GraphSettings): Promise<GraphData>;
+}
+export {};