@real1ty-obsidian-plugins/utils 1.0.0

package/dist/testing/mocks/obsidian.js

@@ -0,0 +1,220 @@
+import { vi } from "vitest";
+// Base Plugin class mock
+export class Plugin {
+    constructor(app, manifest) {
+        // Core plugin methods
+        this.addSettingTab = vi.fn();
+        this.registerEvent = vi.fn();
+        this.loadData = vi.fn().mockResolvedValue({});
+        this.saveData = vi.fn().mockResolvedValue(undefined);
+        this.onload = vi.fn();
+        this.onunload = vi.fn();
+        // UI methods
+        this.addRibbonIcon = vi.fn();
+        this.addStatusBarItem = vi.fn();
+        this.addCommand = vi.fn();
+        this.removeCommand = vi.fn();
+        // Event methods
+        this.registerDomEvent = vi.fn();
+        this.registerCodeMirror = vi.fn();
+        this.registerEditorExtension = vi.fn();
+        this.registerMarkdownPostProcessor = vi.fn();
+        this.registerMarkdownCodeBlockProcessor = vi.fn();
+        this.registerObsidianProtocolHandler = vi.fn();
+        this.registerEditorSuggest = vi.fn();
+        this.registerHoverLinkSource = vi.fn();
+        // Interval methods
+        this.registerInterval = vi.fn();
+        // View and extension methods
+        this.registerView = vi.fn();
+        this.registerExtensions = vi.fn();
+        // Lifecycle methods
+        this.onUserEnable = vi.fn();
+        this.load = vi.fn();
+        this.unload = vi.fn();
+        // Other methods
+        this.addChild = vi.fn();
+        this.removeChild = vi.fn();
+        this.register = vi.fn();
+        this.app = app;
+        this.manifest = manifest;
+    }
+}
+// PluginSettingTab mock
+export class PluginSettingTab {
+    constructor(app, plugin) {
+        this.display = vi.fn();
+        this.app = app;
+        this.plugin = plugin;
+        this.containerEl = document.createElement("div");
+    }
+}
+// ItemView mock
+export class ItemView {
+    constructor(leaf) {
+        this.getState = vi.fn().mockReturnValue({});
+        this.setState = vi.fn().mockResolvedValue(undefined);
+        this.leaf = leaf;
+        this.app = leaf === null || leaf === void 0 ? void 0 : leaf.app;
+        this.containerEl = document.createElement("div");
+    }
+    // Don't override onOpen/onClose - let subclasses implement them
+    // These methods are implemented by MountableView mixin
+    // Don't provide default implementations for these methods
+    // Let subclasses implement them
+    getViewType() {
+        return "mock-view";
+    }
+    getDisplayText() {
+        return "Mock View";
+    }
+    getIcon() {
+        return "mock-icon";
+    }
+}
+// Setting component mock
+export class Setting {
+    constructor(_containerEl) {
+        this.setName = vi.fn().mockReturnThis();
+        this.setDesc = vi.fn().mockReturnThis();
+        this.addText = vi.fn().mockReturnThis();
+        this.addTextArea = vi.fn().mockReturnThis();
+        this.settingEl = document.createElement("div");
+        this.nameEl = document.createElement("div");
+        this.descEl = document.createElement("div");
+        this.controlEl = document.createElement("div");
+    }
+}
+// TFolder mock
+export class TFolder {
+    constructor(path) {
+        this.path = path;
+        this.name = path.split("/").pop() || "";
+        this.children = [];
+        this.vault = {};
+        this.parent = null;
+    }
+    isRoot() {
+        return this.path === "" || this.path === "/";
+    }
+}
+// TFile mock with full interface
+export class TFile {
+    constructor(path, parentPath) {
+        this.path = path;
+        this.name = path.split("/").pop() || "";
+        this.basename = this.name.replace(/\.[^/.]+$/, ""); // Remove extension
+        this.extension = path.split(".").pop() || "md";
+        this.stat = {};
+        this.vault = {};
+        // Set parent based on path or explicit parentPath
+        if (parentPath !== undefined) {
+            this.parent = parentPath ? new TFolder(parentPath) : null;
+        }
+        else {
+            // Derive parent from path
+            const lastSlash = path.lastIndexOf("/");
+            if (lastSlash > 0) {
+                this.parent = new TFolder(path.substring(0, lastSlash));
+            }
+            else {
+                this.parent = null;
+            }
+        }
+    }
+}
+// Modal mock
+export class Modal {
+    constructor(app) {
+        this.open = vi.fn();
+        this.close = vi.fn();
+        this.onOpen = vi.fn();
+        this.onClose = vi.fn();
+        this.app = app;
+        this.containerEl = document.createElement("div");
+        this.titleEl = document.createElement("div");
+        this.contentEl = document.createElement("div");
+    }
+}
+// Notice mock
+export class Notice {
+    constructor(message) {
+        console.log(`Notice: ${message}`);
+    }
+}
+// MarkdownRenderer mock
+export const MarkdownRenderer = {
+    render: vi.fn().mockResolvedValue(undefined),
+};
+// Debounce function mock
+export function debounce(func, wait, immediate) {
+    let timeout = null;
+    return ((...args) => {
+        const later = () => {
+            timeout = null;
+            if (!immediate)
+                func(...args);
+        };
+        const callNow = immediate && !timeout;
+        if (timeout !== null) {
+            clearTimeout(timeout);
+        }
+        timeout = setTimeout(later, wait);
+        if (callNow)
+            func(...args);
+    });
+}
+// App mock
+export const App = vi.fn();
+// Helper function to create a fully mocked app
+export function createMockApp() {
+    return {
+        fileManager: {
+            processFrontMatter: vi.fn(),
+        },
+        metadataCache: {
+            getFileCache: vi.fn(),
+        },
+        vault: {
+            getAbstractFileByPath: vi.fn(),
+            on: vi.fn(),
+            read: vi.fn(),
+            modify: vi.fn(),
+            create: vi.fn(),
+            delete: vi.fn(),
+            rename: vi.fn(),
+            getFiles: vi.fn().mockReturnValue([]),
+            getMarkdownFiles: vi.fn().mockReturnValue([]),
+            getFolderByPath: vi.fn(),
+        },
+        workspace: {
+            getActiveFile: vi.fn(),
+            on: vi.fn(),
+        },
+    };
+}
+// Helper to create mock TFile instances
+export function createMockFile(path, options) {
+    const file = new TFile(path, options === null || options === void 0 ? void 0 : options.parentPath);
+    if (options === null || options === void 0 ? void 0 : options.basename) {
+        file.basename = options.basename;
+    }
+    if (options === null || options === void 0 ? void 0 : options.extension) {
+        file.extension = options.extension;
+    }
+    return file;
+}
+// Helper to create mock file cache
+export function createMockFileCache(frontmatter) {
+    return {
+        frontmatter: frontmatter || {},
+        frontmatterPosition: frontmatter ? { start: { line: 0 }, end: { line: 3 } } : null,
+        sections: [],
+        headings: [],
+        links: [],
+        embeds: [],
+        tags: [],
+        listItems: [],
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"obsidian.js","sourceRoot":"","sources":["../../../src/testing/mocks/obsidian.ts"],"names":[],"mappings":"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","sourcesContent":["import { vi } from \"vitest\";\n\n// Base Plugin class mock\nexport class Plugin {\n\tapp: any;\n\tmanifest: any;\n\tsettings: any;\n\n\tconstructor(app: any, manifest: any) {\n\t\tthis.app = app;\n\t\tthis.manifest = manifest;\n\t}\n\n\t// Core plugin methods\n\taddSettingTab = vi.fn();\n\tregisterEvent = vi.fn();\n\tloadData = vi.fn().mockResolvedValue({});\n\tsaveData = vi.fn().mockResolvedValue(undefined);\n\tonload = vi.fn();\n\tonunload = vi.fn();\n\n\t// UI methods\n\taddRibbonIcon = vi.fn();\n\taddStatusBarItem = vi.fn();\n\taddCommand = vi.fn();\n\tremoveCommand = vi.fn();\n\n\t// Event methods\n\tregisterDomEvent = vi.fn();\n\tregisterCodeMirror = vi.fn();\n\tregisterEditorExtension = vi.fn();\n\tregisterMarkdownPostProcessor = vi.fn();\n\tregisterMarkdownCodeBlockProcessor = vi.fn();\n\tregisterObsidianProtocolHandler = vi.fn();\n\tregisterEditorSuggest = vi.fn();\n\tregisterHoverLinkSource = vi.fn();\n\n\t// Interval methods\n\tregisterInterval = vi.fn();\n\n\t// View and extension methods\n\tregisterView = vi.fn();\n\tregisterExtensions = vi.fn();\n\n\t// Lifecycle methods\n\tonUserEnable = vi.fn();\n\tload = vi.fn();\n\tunload = vi.fn();\n\n\t// Other methods\n\taddChild = vi.fn();\n\tremoveChild = vi.fn();\n\tregister = vi.fn();\n}\n\n// PluginSettingTab mock\nexport class PluginSettingTab {\n\tapp: any;\n\tplugin: any;\n\tcontainerEl: HTMLElement;\n\n\tconstructor(app: any, plugin: any) {\n\t\tthis.app = app;\n\t\tthis.plugin = plugin;\n\t\tthis.containerEl = document.createElement(\"div\");\n\t}\n\n\tdisplay = vi.fn();\n}\n\n// ItemView mock\nexport class ItemView {\n\tapp: any;\n\tleaf: any;\n\tcontainerEl: HTMLElement;\n\n\tconstructor(leaf: any) {\n\t\tthis.leaf = leaf;\n\t\tthis.app = leaf?.app;\n\t\tthis.containerEl = document.createElement(\"div\");\n\t}\n\n\t// Don't override onOpen/onClose - let subclasses implement them\n\t// These methods are implemented by MountableView mixin\n\n\t// Don't provide default implementations for these methods\n\t// Let subclasses implement them\n\tgetViewType(): string {\n\t\treturn \"mock-view\";\n\t}\n\n\tgetDisplayText(): string {\n\t\treturn \"Mock View\";\n\t}\n\n\tgetIcon(): string {\n\t\treturn \"mock-icon\";\n\t}\n\n\tgetState = vi.fn().mockReturnValue({});\n\tsetState = vi.fn().mockResolvedValue(undefined);\n}\n\n// Setting component mock\nexport class Setting {\n\tsettingEl: HTMLElement;\n\tnameEl: HTMLElement;\n\tdescEl: HTMLElement;\n\tcontrolEl: HTMLElement;\n\n\tconstructor(_containerEl: HTMLElement) {\n\t\tthis.settingEl = document.createElement(\"div\");\n\t\tthis.nameEl = document.createElement(\"div\");\n\t\tthis.descEl = document.createElement(\"div\");\n\t\tthis.controlEl = document.createElement(\"div\");\n\t}\n\n\tsetName = vi.fn().mockReturnThis();\n\tsetDesc = vi.fn().mockReturnThis();\n\taddText = vi.fn().mockReturnThis();\n\taddTextArea = vi.fn().mockReturnThis();\n}\n\n// TFolder mock\nexport class TFolder {\n\tpath: string;\n\tname: string;\n\tchildren: any[];\n\tvault: any;\n\tparent: TFolder | null;\n\n\tconstructor(path: string) {\n\t\tthis.path = path;\n\t\tthis.name = path.split(\"/\").pop() || \"\";\n\t\tthis.children = [];\n\t\tthis.vault = {};\n\t\tthis.parent = null;\n\t}\n\n\tisRoot(): boolean {\n\t\treturn this.path === \"\" || this.path === \"/\";\n\t}\n}\n\n// TFile mock with full interface\nexport class TFile {\n\tpath: string;\n\tname: string;\n\tbasename: string;\n\textension: string;\n\tstat: any;\n\tvault: any;\n\tparent: TFolder | null;\n\n\tconstructor(path: string, parentPath?: string) {\n\t\tthis.path = path;\n\t\tthis.name = path.split(\"/\").pop() || \"\";\n\t\tthis.basename = this.name.replace(/\\.[^/.]+$/, \"\"); // Remove extension\n\t\tthis.extension = path.split(\".\").pop() || \"md\";\n\t\tthis.stat = {};\n\t\tthis.vault = {};\n\n\t\t// Set parent based on path or explicit parentPath\n\t\tif (parentPath !== undefined) {\n\t\t\tthis.parent = parentPath ? new TFolder(parentPath) : null;\n\t\t} else {\n\t\t\t// Derive parent from path\n\t\t\tconst lastSlash = path.lastIndexOf(\"/\");\n\t\t\tif (lastSlash > 0) {\n\t\t\t\tthis.parent = new TFolder(path.substring(0, lastSlash));\n\t\t\t} else {\n\t\t\t\tthis.parent = null;\n\t\t\t}\n\t\t}\n\t}\n}\n\n// Modal mock\nexport class Modal {\n\tapp: any;\n\tcontainerEl: HTMLElement;\n\ttitleEl: HTMLElement;\n\tcontentEl: HTMLElement;\n\n\tconstructor(app: any) {\n\t\tthis.app = app;\n\t\tthis.containerEl = document.createElement(\"div\");\n\t\tthis.titleEl = document.createElement(\"div\");\n\t\tthis.contentEl = document.createElement(\"div\");\n\t}\n\n\topen = vi.fn();\n\tclose = vi.fn();\n\tonOpen = vi.fn();\n\tonClose = vi.fn();\n}\n\n// Notice mock\nexport class Notice {\n\tconstructor(message: string) {\n\t\tconsole.log(`Notice: ${message}`);\n\t}\n}\n\n// MarkdownRenderer mock\nexport const MarkdownRenderer = {\n\trender: vi.fn().mockResolvedValue(undefined),\n};\n\n// Debounce function mock\nexport function debounce<T extends (...args: any[]) => any>(\n\tfunc: T,\n\twait: number,\n\timmediate?: boolean\n): T {\n\tlet timeout: ReturnType<typeof setTimeout> | null = null;\n\n\treturn ((...args: Parameters<T>) => {\n\t\tconst later = () => {\n\t\t\ttimeout = null;\n\t\t\tif (!immediate) func(...args);\n\t\t};\n\n\t\tconst callNow = immediate && !timeout;\n\n\t\tif (timeout !== null) {\n\t\t\tclearTimeout(timeout);\n\t\t}\n\n\t\ttimeout = setTimeout(later, wait);\n\n\t\tif (callNow) func(...args);\n\t}) as T;\n}\n\n// App mock\nexport const App = vi.fn();\n\n// Mock interfaces for TypeScript\nexport interface MockApp {\n\tfileManager: {\n\t\tprocessFrontMatter: ReturnType<typeof vi.fn>;\n\t};\n\tmetadataCache: {\n\t\tgetFileCache: ReturnType<typeof vi.fn>;\n\t};\n\tvault: {\n\t\tgetAbstractFileByPath: ReturnType<typeof vi.fn>;\n\t\ton: ReturnType<typeof vi.fn>;\n\t\tread: ReturnType<typeof vi.fn>;\n\t\tmodify: ReturnType<typeof vi.fn>;\n\t\tcreate: ReturnType<typeof vi.fn>;\n\t\tdelete: ReturnType<typeof vi.fn>;\n\t\trename: ReturnType<typeof vi.fn>;\n\t\tgetFiles: ReturnType<typeof vi.fn>;\n\t\tgetMarkdownFiles: ReturnType<typeof vi.fn>;\n\t\tgetFolderByPath: ReturnType<typeof vi.fn>;\n\t};\n\tworkspace: {\n\t\tgetActiveFile: ReturnType<typeof vi.fn>;\n\t\ton: ReturnType<typeof vi.fn>;\n\t};\n}\n\n// Helper function to create a fully mocked app\nexport function createMockApp(): MockApp {\n\treturn {\n\t\tfileManager: {\n\t\t\tprocessFrontMatter: vi.fn(),\n\t\t},\n\t\tmetadataCache: {\n\t\t\tgetFileCache: vi.fn(),\n\t\t},\n\t\tvault: {\n\t\t\tgetAbstractFileByPath: vi.fn(),\n\t\t\ton: vi.fn(),\n\t\t\tread: vi.fn(),\n\t\t\tmodify: vi.fn(),\n\t\t\tcreate: vi.fn(),\n\t\t\tdelete: vi.fn(),\n\t\t\trename: vi.fn(),\n\t\t\tgetFiles: vi.fn().mockReturnValue([]),\n\t\t\tgetMarkdownFiles: vi.fn().mockReturnValue([]),\n\t\t\tgetFolderByPath: vi.fn(),\n\t\t},\n\t\tworkspace: {\n\t\t\tgetActiveFile: vi.fn(),\n\t\t\ton: vi.fn(),\n\t\t},\n\t};\n}\n\n// Helper to create mock TFile instances\nexport function createMockFile(\n\tpath: string,\n\toptions?: {\n\t\tbasename?: string;\n\t\tparentPath?: string;\n\t\textension?: string;\n\t}\n): TFile {\n\tconst file = new TFile(path, options?.parentPath);\n\tif (options?.basename) {\n\t\tfile.basename = options.basename;\n\t}\n\tif (options?.extension) {\n\t\tfile.extension = options.extension;\n\t}\n\treturn file;\n}\n\n// Helper to create mock file cache\nexport function createMockFileCache(frontmatter?: Record<string, any>) {\n\treturn {\n\t\tfrontmatter: frontmatter || {},\n\t\tfrontmatterPosition: frontmatter ? { start: { line: 0 }, end: { line: 3 } } : null,\n\t\tsections: [],\n\t\theadings: [],\n\t\tlinks: [],\n\t\tembeds: [],\n\t\ttags: [],\n\t\tlistItems: [],\n\t};\n}\n"]}

package/dist/testing/mocks/utils.d.ts

@@ -0,0 +1,14 @@
+export declare const mockFileOperations: {
+    arraysEqual: import("vitest").Mock<(...args: any[]) => any>;
+    normalizeArray: import("vitest").Mock<(...args: any[]) => any>;
+    createFileLink: import("vitest").Mock<(...args: any[]) => any>;
+};
+export declare const mockLinkParser: {
+    extractFilePathFromLink: import("vitest").Mock<(...args: any[]) => any>;
+};
+export declare function setupDefaultMockImplementations(): void;
+export declare function resetAllMocks(): void;
+export declare function setupMockImplementation(mockName: keyof typeof mockFileOperations | keyof typeof mockLinkParser, implementation: (...args: any[]) => any): void;
+export declare function setupMockReturnValue(mockName: keyof typeof mockFileOperations | keyof typeof mockLinkParser, value: any): void;
+export declare function verifyMockCalls(mockName: keyof typeof mockFileOperations | keyof typeof mockLinkParser, expectedCalls: any[][]): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/testing/mocks/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/testing/mocks/utils.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB;;;;CAI9B,CAAC;AAGF,eAAO,MAAM,cAAc;;CAE1B,CAAC;AAGF,wBAAgB,+BAA+B,SA+C9C;AAGD,wBAAgB,aAAa,SAO5B;AAGD,wBAAgB,uBAAuB,CACtC,QAAQ,EAAE,MAAM,OAAO,kBAAkB,GAAG,MAAM,OAAO,cAAc,EACvE,cAAc,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,QAOvC;AAGD,wBAAgB,oBAAoB,CACnC,QAAQ,EAAE,MAAM,OAAO,kBAAkB,GAAG,MAAM,OAAO,cAAc,EACvE,KAAK,EAAE,GAAG,QAOV;AAGD,wBAAgB,eAAe,CAC9B,QAAQ,EAAE,MAAM,OAAO,kBAAkB,GAAG,MAAM,OAAO,cAAc,EACvE,aAAa,EAAE,GAAG,EAAE,EAAE,QAWtB"}

package/dist/testing/mocks/utils.js

@@ -0,0 +1,85 @@
+import { expect, vi } from "vitest";
+// File operations mocks
+export const mockFileOperations = {
+    arraysEqual: vi.fn(),
+    normalizeArray: vi.fn(),
+    createFileLink: vi.fn(),
+};
+// Link parser mocks
+export const mockLinkParser = {
+    extractFilePathFromLink: vi.fn(),
+};
+// Default mock implementations that match the actual behavior
+export function setupDefaultMockImplementations() {
+    // Set up file operations mocks
+    mockFileOperations.normalizeArray.mockImplementation((arr) => Array.isArray(arr) ? arr : arr ? [arr] : []);
+    mockFileOperations.arraysEqual.mockImplementation((a, b) => JSON.stringify(a) === JSON.stringify(b));
+    mockFileOperations.createFileLink.mockImplementation((file) => {
+        var _a, _b, _c;
+        if (!file)
+            return "[[Unknown File]]";
+        const basename = file.basename ||
+            ((_b = (_a = file.path) === null || _a === void 0 ? void 0 : _a.split("/").pop()) === null || _b === void 0 ? void 0 : _b.replace(/\.[^/.]+$/, "")) ||
+            "";
+        const parentPath = (_c = file.parent) === null || _c === void 0 ? void 0 : _c.path;
+        if (!parentPath || parentPath === "/" || parentPath === "") {
+            return `[[${basename}]]`;
+        }
+        return `[[${parentPath}/${basename}|${basename}]]`;
+    });
+    // Set up link parser mocks
+    mockLinkParser.extractFilePathFromLink.mockImplementation((link) => {
+        if (!link || typeof link !== "string")
+            return null;
+        // Handle text that contains a link
+        const linkMatch = link.match(/\[\[([^\]]+)\]\]/);
+        if (linkMatch) {
+            const content = linkMatch[1];
+            // Remove display name if present
+            const filePart = content.split("|")[0].trim();
+            if (!filePart)
+                return null;
+            // Add .md extension if not present
+            return filePart.endsWith(".md") ? filePart : `${filePart}.md`;
+        }
+        return null;
+    });
+}
+// Reset all mocks
+export function resetAllMocks() {
+    Object.values(mockFileOperations).forEach((mock) => {
+        mock.mockReset();
+    });
+    Object.values(mockLinkParser).forEach((mock) => {
+        mock.mockReset();
+    });
+}
+// Helper to setup mocks with specific implementations
+export function setupMockImplementation(mockName, implementation) {
+    if (mockName in mockFileOperations) {
+        mockFileOperations[mockName].mockImplementation(implementation);
+    }
+    else if (mockName in mockLinkParser) {
+        mockLinkParser[mockName].mockImplementation(implementation);
+    }
+}
+// Helper to setup mock return values
+export function setupMockReturnValue(mockName, value) {
+    if (mockName in mockFileOperations) {
+        mockFileOperations[mockName].mockReturnValue(value);
+    }
+    else if (mockName in mockLinkParser) {
+        mockLinkParser[mockName].mockReturnValue(value);
+    }
+}
+// Helper to verify mock calls
+export function verifyMockCalls(mockName, expectedCalls) {
+    const mock = mockName in mockFileOperations
+        ? mockFileOperations[mockName]
+        : mockLinkParser[mockName];
+    expect(mock).toHaveBeenCalledTimes(expectedCalls.length);
+    expectedCalls.forEach((args, index) => {
+        expect(mock).toHaveBeenNthCalledWith(index + 1, ...args);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/testing/mocks/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { expect, vi } from \"vitest\";\n\n// File operations mocks\nexport const mockFileOperations = {\n\tarraysEqual: vi.fn(),\n\tnormalizeArray: vi.fn(),\n\tcreateFileLink: vi.fn(),\n};\n\n// Link parser mocks\nexport const mockLinkParser = {\n\textractFilePathFromLink: vi.fn(),\n};\n\n// Default mock implementations that match the actual behavior\nexport function setupDefaultMockImplementations() {\n\t// Set up file operations mocks\n\tmockFileOperations.normalizeArray.mockImplementation((arr) =>\n\t\tArray.isArray(arr) ? arr : arr ? [arr] : []\n\t);\n\n\tmockFileOperations.arraysEqual.mockImplementation(\n\t\t(a, b) => JSON.stringify(a) === JSON.stringify(b)\n\t);\n\n\tmockFileOperations.createFileLink.mockImplementation((file) => {\n\t\tif (!file) return \"[[Unknown File]]\";\n\n\t\tconst basename =\n\t\t\tfile.basename ||\n\t\t\tfile.path\n\t\t\t\t?.split(\"/\")\n\t\t\t\t.pop()\n\t\t\t\t?.replace(/\\.[^/.]+$/, \"\") ||\n\t\t\t\"\";\n\t\tconst parentPath = file.parent?.path;\n\n\t\tif (!parentPath || parentPath === \"/\" || parentPath === \"\") {\n\t\t\treturn `[[${basename}]]`;\n\t\t}\n\n\t\treturn `[[${parentPath}/${basename}|${basename}]]`;\n\t});\n\n\t// Set up link parser mocks\n\tmockLinkParser.extractFilePathFromLink.mockImplementation((link) => {\n\t\tif (!link || typeof link !== \"string\") return null;\n\n\t\t// Handle text that contains a link\n\t\tconst linkMatch = link.match(/\\[\\[([^\\]]+)\\]\\]/);\n\t\tif (linkMatch) {\n\t\t\tconst content = linkMatch[1];\n\t\t\t// Remove display name if present\n\t\t\tconst filePart = content.split(\"|\")[0].trim();\n\t\t\tif (!filePart) return null;\n\n\t\t\t// Add .md extension if not present\n\t\t\treturn filePart.endsWith(\".md\") ? filePart : `${filePart}.md`;\n\t\t}\n\n\t\treturn null;\n\t});\n}\n\n// Reset all mocks\nexport function resetAllMocks() {\n\tObject.values(mockFileOperations).forEach((mock) => {\n\t\tmock.mockReset();\n\t});\n\tObject.values(mockLinkParser).forEach((mock) => {\n\t\tmock.mockReset();\n\t});\n}\n\n// Helper to setup mocks with specific implementations\nexport function setupMockImplementation(\n\tmockName: keyof typeof mockFileOperations | keyof typeof mockLinkParser,\n\timplementation: (...args: any[]) => any\n) {\n\tif (mockName in mockFileOperations) {\n\t\t(mockFileOperations as any)[mockName].mockImplementation(implementation);\n\t} else if (mockName in mockLinkParser) {\n\t\t(mockLinkParser as any)[mockName].mockImplementation(implementation);\n\t}\n}\n\n// Helper to setup mock return values\nexport function setupMockReturnValue(\n\tmockName: keyof typeof mockFileOperations | keyof typeof mockLinkParser,\n\tvalue: any\n) {\n\tif (mockName in mockFileOperations) {\n\t\t(mockFileOperations as any)[mockName].mockReturnValue(value);\n\t} else if (mockName in mockLinkParser) {\n\t\t(mockLinkParser as any)[mockName].mockReturnValue(value);\n\t}\n}\n\n// Helper to verify mock calls\nexport function verifyMockCalls(\n\tmockName: keyof typeof mockFileOperations | keyof typeof mockLinkParser,\n\texpectedCalls: any[][]\n) {\n\tconst mock =\n\t\tmockName in mockFileOperations\n\t\t\t? (mockFileOperations as any)[mockName]\n\t\t\t: (mockLinkParser as any)[mockName];\n\n\texpect(mock).toHaveBeenCalledTimes(expectedCalls.length);\n\texpectedCalls.forEach((args, index) => {\n\t\texpect(mock).toHaveBeenNthCalledWith(index + 1, ...args);\n\t});\n}\n"]}

package/dist/testing/setup.d.ts

@@ -0,0 +1,2 @@
+export declare function setupTestEnvironment(): () => void;
+//# sourceMappingURL=setup.d.ts.map

package/dist/testing/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/testing/setup.ts"],"names":[],"mappings":"AAIA,wBAAgB,oBAAoB,eAcnC"}

package/dist/testing/setup.js

@@ -0,0 +1,18 @@
+import { vi } from "vitest";
+import { mockFileOperations, mockLinkParser } from "./mocks/utils";
+// Global test setup that can be imported once per test file
+export function setupTestEnvironment() {
+    // Mock the utils modules
+    vi.mock("@obsidian-plugins/utils/file-operations", () => mockFileOperations);
+    vi.mock("@obsidian-plugins/utils/link-parser", () => mockLinkParser);
+    // Mock any plugin-specific components
+    vi.mock("../src/components/settings-tab", () => ({
+        TreePropertiesManagerSettingTab: class MockSettingTab {
+        },
+    }));
+    // Return cleanup function
+    return () => {
+        vi.clearAllMocks();
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0dXAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGluZy9zZXR1cC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBQzVCLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFbkUsNERBQTREO0FBQzVELE1BQU0sVUFBVSxvQkFBb0I7SUFDbkMseUJBQXlCO0lBQ3pCLEVBQUUsQ0FBQyxJQUFJLENBQUMseUNBQXlDLEVBQUUsR0FBRyxFQUFFLENBQUMsa0JBQWtCLENBQUMsQ0FBQztJQUM3RSxFQUFFLENBQUMsSUFBSSxDQUFDLHFDQUFxQyxFQUFFLEdBQUcsRUFBRSxDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBRXJFLHNDQUFzQztJQUN0QyxFQUFFLENBQUMsSUFBSSxDQUFDLGdDQUFnQyxFQUFFLEdBQUcsRUFBRSxDQUFDLENBQUM7UUFDaEQsK0JBQStCLEVBQUUsTUFBTSxjQUFjO1NBQUc7S0FDeEQsQ0FBQyxDQUFDLENBQUM7SUFFSiwwQkFBMEI7SUFDMUIsT0FBTyxHQUFHLEVBQUU7UUFDWCxFQUFFLENBQUMsYUFBYSxFQUFFLENBQUM7SUFDcEIsQ0FBQyxDQUFDO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHZpIH0gZnJvbSBcInZpdGVzdFwiO1xuaW1wb3J0IHsgbW9ja0ZpbGVPcGVyYXRpb25zLCBtb2NrTGlua1BhcnNlciB9IGZyb20gXCIuL21vY2tzL3V0aWxzXCI7XG5cbi8vIEdsb2JhbCB0ZXN0IHNldHVwIHRoYXQgY2FuIGJlIGltcG9ydGVkIG9uY2UgcGVyIHRlc3QgZmlsZVxuZXhwb3J0IGZ1bmN0aW9uIHNldHVwVGVzdEVudmlyb25tZW50KCkge1xuXHQvLyBNb2NrIHRoZSB1dGlscyBtb2R1bGVzXG5cdHZpLm1vY2soXCJAb2JzaWRpYW4tcGx1Z2lucy91dGlscy9maWxlLW9wZXJhdGlvbnNcIiwgKCkgPT4gbW9ja0ZpbGVPcGVyYXRpb25zKTtcblx0dmkubW9jayhcIkBvYnNpZGlhbi1wbHVnaW5zL3V0aWxzL2xpbmstcGFyc2VyXCIsICgpID0+IG1vY2tMaW5rUGFyc2VyKTtcblxuXHQvLyBNb2NrIGFueSBwbHVnaW4tc3BlY2lmaWMgY29tcG9uZW50c1xuXHR2aS5tb2NrKFwiLi4vc3JjL2NvbXBvbmVudHMvc2V0dGluZ3MtdGFiXCIsICgpID0+ICh7XG5cdFx0VHJlZVByb3BlcnRpZXNNYW5hZ2VyU2V0dGluZ1RhYjogY2xhc3MgTW9ja1NldHRpbmdUYWIge30sXG5cdH0pKTtcblxuXHQvLyBSZXR1cm4gY2xlYW51cCBmdW5jdGlvblxuXHRyZXR1cm4gKCkgPT4ge1xuXHRcdHZpLmNsZWFyQWxsTW9ja3MoKTtcblx0fTtcbn1cbiJdfQ==

package/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "@real1ty-obsidian-plugins/utils",
+  "version": "1.0.0",
+  "description": "Shared utilities for Obsidian plugins",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "obsidian",
+    "utilities",
+    "plugins",
+    "typescript"
+  ],
+  "author": "Real1ty",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Real1tyy/Real1ty-Obsidian-Plugins",
+    "directory": "libs/utils"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@types/luxon": "^3.7.1",
+    "typescript": "5.9.2",
+    "vitest": "^2.0.5"
+  },
+  "dependencies": {
+    "gray-matter": "^4.0.3",
+    "luxon": "^3.7.2",
+    "obsidian": "^1.8.7",
+    "rxjs": "^7.8.2",
+    "tslib": "2.8.1",
+    "zod": "^4.1.5"
+  },
+  "nx": {
+    "sourceRoot": "libs/utils/src",
+    "targets": {
+      "build": {
+        "executor": "nx:run-commands",
+        "options": {
+          "command": "pnpm build",
+          "cwd": "{projectRoot}"
+        }
+      },
+      "test": {
+        "executor": "nx:run-commands",
+        "options": {
+          "command": "pnpm test",
+          "cwd": "{projectRoot}"
+        }
+      },
+      "test:watch": {
+        "executor": "nx:run-commands",
+        "options": {
+          "command": "pnpm test:watch",
+          "cwd": "{projectRoot}"
+        }
+      },
+      "typecheck": {
+        "executor": "nx:run-commands",
+        "options": {
+          "command": "pnpm typecheck",
+          "cwd": "{projectRoot}"
+        }
+      },
+      "clean": {
+        "executor": "nx:run-commands",
+        "options": {
+          "command": "pnpm clean",
+          "cwd": "{projectRoot}"
+        }
+      }
+    },
+    "tags": [
+      "type:lib",
+      "scope:shared"
+    ]
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "typecheck": "tsc -noEmit",
+    "clean": "rm -rf dist",
+    "minor-release": "pnpm version minor && pnpm publish",
+    "major-release": "pnpm version major && pnpm publish",
+    "breaking-release": "pnpm version major && pnpm publish"
+  }
+}