@real1ty-obsidian-plugins/utils 2.3.0 → 2.5.0

package/src/string/string.ts

@@ -0,0 +1,26 @@
+export const capitalize = (str: string): string => {
+	if (!str) return str;
+	return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+};
+
+export const generateDuplicatedTitle = (originalTitle: string): string => {
+	// Check if title already has a counter pattern like " (2)", " - Copy", etc.
+	const counterMatch = originalTitle.match(/^(.*?)(?:\s*\((\d+)\)|\s*-?\s*Copy(?:\s*(\d+))?)$/);
+
+	if (counterMatch) {
+		const baseName = counterMatch[1];
+		const existingCounter = counterMatch[2] || counterMatch[3];
+		const nextCounter = existingCounter ? parseInt(existingCounter, 10) + 1 : 2;
+		return `${baseName} (${nextCounter})`;
+	} else {
+		return `${originalTitle} (2)`;
+	}
+};
+
+export const pluralize = (count: number): string => {
+	return count === 1 ? "" : "s";
+};
+
+export const getWeekDirection = (weeks: number): "next" | "previous" => {
+	return weeks > 0 ? "next" : "previous";
+};

package/src/testing/index.ts

@@ -0,0 +1,23 @@
+export * from "./mocks/obsidian";
+// Re-export commonly used combinations
+export {
+	createMockApp,
+	createMockFile,
+	createMockFileCache,
+	Modal,
+	Notice,
+	Plugin,
+	PluginSettingTab,
+	Setting,
+	TFile,
+} from "./mocks/obsidian";
+export * from "./mocks/utils";
+export {
+	mockFileOperations,
+	mockLinkParser,
+	resetAllMocks,
+	setupDefaultMockImplementations,
+	setupMockImplementation,
+	setupMockReturnValue,
+	verifyMockCalls,
+} from "./mocks/utils";

package/src/testing/mocks/obsidian.ts

@@ -0,0 +1,331 @@
+import { vi } from "vitest";
+
+// Base Plugin class mock
+export class Plugin {
+	app: any;
+	manifest: any;
+	settings: any;
+
+	constructor(app: any, manifest: any) {
+		this.app = app;
+		this.manifest = manifest;
+	}
+
+	// Core plugin methods
+	addSettingTab = vi.fn();
+	registerEvent = vi.fn();
+	loadData = vi.fn().mockResolvedValue({});
+	saveData = vi.fn().mockResolvedValue(undefined);
+	onload = vi.fn();
+	onunload = vi.fn();
+
+	// UI methods
+	addRibbonIcon = vi.fn();
+	addStatusBarItem = vi.fn();
+	addCommand = vi.fn();
+	removeCommand = vi.fn();
+
+	// Event methods
+	registerDomEvent = vi.fn();
+	registerCodeMirror = vi.fn();
+	registerEditorExtension = vi.fn();
+	registerMarkdownPostProcessor = vi.fn();
+	registerMarkdownCodeBlockProcessor = vi.fn();
+	registerObsidianProtocolHandler = vi.fn();
+	registerEditorSuggest = vi.fn();
+	registerHoverLinkSource = vi.fn();
+
+	// Interval methods
+	registerInterval = vi.fn();
+
+	// View and extension methods
+	registerView = vi.fn();
+	registerExtensions = vi.fn();
+
+	// Lifecycle methods
+	onUserEnable = vi.fn();
+	load = vi.fn();
+	unload = vi.fn();
+
+	// Other methods
+	addChild = vi.fn();
+	removeChild = vi.fn();
+	register = vi.fn();
+}
+
+// PluginSettingTab mock
+export class PluginSettingTab {
+	app: any;
+	plugin: any;
+	containerEl: HTMLElement;
+
+	constructor(app: any, plugin: any) {
+		this.app = app;
+		this.plugin = plugin;
+		this.containerEl = document.createElement("div");
+	}
+
+	display = vi.fn();
+}
+
+// ItemView mock
+export class ItemView {
+	app: any;
+	leaf: any;
+	containerEl: HTMLElement;
+
+	constructor(leaf: any) {
+		this.leaf = leaf;
+		this.app = 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(): string {
+		return "mock-view";
+	}
+
+	getDisplayText(): string {
+		return "Mock View";
+	}
+
+	getIcon(): string {
+		return "mock-icon";
+	}
+
+	getState = vi.fn().mockReturnValue({});
+	setState = vi.fn().mockResolvedValue(undefined);
+}
+
+// Setting component mock
+export class Setting {
+	settingEl: HTMLElement;
+	nameEl: HTMLElement;
+	descEl: HTMLElement;
+	controlEl: HTMLElement;
+
+	constructor(_containerEl: HTMLElement) {
+		this.settingEl = document.createElement("div");
+		this.nameEl = document.createElement("div");
+		this.descEl = document.createElement("div");
+		this.controlEl = document.createElement("div");
+	}
+
+	setName = vi.fn().mockReturnThis();
+	setDesc = vi.fn().mockReturnThis();
+	addText = vi.fn().mockReturnThis();
+	addTextArea = vi.fn().mockReturnThis();
+}
+
+// TFolder mock
+export class TFolder {
+	path: string;
+	name: string;
+	children: any[];
+	vault: any;
+	parent: TFolder | null;
+
+	constructor(path: string) {
+		this.path = path;
+		this.name = path.split("/").pop() || "";
+		this.children = [];
+		this.vault = {};
+		this.parent = null;
+	}
+
+	isRoot(): boolean {
+		return this.path === "" || this.path === "/";
+	}
+}
+
+// TFile mock with full interface
+export class TFile {
+	path: string;
+	name: string;
+	basename: string;
+	extension: string;
+	stat: any;
+	vault: any;
+	parent: TFolder | null;
+
+	constructor(path: string, parentPath?: string) {
+		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 {
+	app: any;
+	containerEl: HTMLElement;
+	titleEl: HTMLElement;
+	contentEl: HTMLElement;
+
+	constructor(app: any) {
+		this.app = app;
+		this.containerEl = document.createElement("div");
+		this.titleEl = document.createElement("div");
+		this.contentEl = document.createElement("div");
+	}
+
+	open = vi.fn();
+	close = vi.fn();
+	onOpen = vi.fn();
+	onClose = vi.fn();
+}
+
+// Notice mock
+export class Notice {
+	constructor(message: string) {
+		console.log(`Notice: ${message}`);
+	}
+}
+
+// MarkdownRenderer mock
+export const MarkdownRenderer = {
+	render: vi.fn().mockResolvedValue(undefined),
+};
+
+// Debounce function mock
+export function debounce<T extends (...args: any[]) => any>(
+	func: T,
+	wait: number,
+	immediate?: boolean
+): T {
+	let timeout: ReturnType<typeof setTimeout> | null = null;
+
+	return ((...args: Parameters<T>) => {
+		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);
+	}) as T;
+}
+
+// normalizePath mock - simple path normalization for tests
+export function normalizePath(path: string): string {
+	// Basic normalization: replace backslashes with forward slashes
+	// and remove duplicate slashes
+	return path.replace(/\\/g, "/").replace(/\/+/g, "/");
+}
+
+// App mock
+export const App = vi.fn();
+
+// Mock interfaces for TypeScript
+export interface MockApp {
+	fileManager: {
+		processFrontMatter: ReturnType<typeof vi.fn>;
+	};
+	metadataCache: {
+		getFileCache: ReturnType<typeof vi.fn>;
+	};
+	vault: {
+		getAbstractFileByPath: ReturnType<typeof vi.fn>;
+		on: ReturnType<typeof vi.fn>;
+		read: ReturnType<typeof vi.fn>;
+		modify: ReturnType<typeof vi.fn>;
+		create: ReturnType<typeof vi.fn>;
+		delete: ReturnType<typeof vi.fn>;
+		rename: ReturnType<typeof vi.fn>;
+		getFiles: ReturnType<typeof vi.fn>;
+		getMarkdownFiles: ReturnType<typeof vi.fn>;
+		getFolderByPath: ReturnType<typeof vi.fn>;
+	};
+	workspace: {
+		getActiveFile: ReturnType<typeof vi.fn>;
+		on: ReturnType<typeof vi.fn>;
+	};
+}
+
+// Helper function to create a fully mocked app
+export function createMockApp(): MockApp {
+	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: string,
+	options?: {
+		basename?: string;
+		parentPath?: string;
+		extension?: string;
+	}
+): TFile {
+	const file = new TFile(path, options?.parentPath);
+	if (options?.basename) {
+		file.basename = options.basename;
+	}
+	if (options?.extension) {
+		file.extension = options.extension;
+	}
+	return file;
+}
+
+// Helper to create mock file cache
+export function createMockFileCache(frontmatter?: Record<string, any>) {
+	return {
+		frontmatter: frontmatter || {},
+		frontmatterPosition: frontmatter ? { start: { line: 0 }, end: { line: 3 } } : null,
+		sections: [],
+		headings: [],
+		links: [],
+		embeds: [],
+		tags: [],
+		listItems: [],
+	};
+}

package/src/testing/mocks/utils.ts

@@ -0,0 +1,113 @@
+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) => {
+		if (!file) return "[[Unknown File]]";
+
+		const basename =
+			file.basename ||
+			file.path
+				?.split("/")
+				.pop()
+				?.replace(/\.[^/.]+$/, "") ||
+			"";
+		const parentPath = file.parent?.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: keyof typeof mockFileOperations | keyof typeof mockLinkParser,
+	implementation: (...args: any[]) => any
+) {
+	if (mockName in mockFileOperations) {
+		(mockFileOperations as any)[mockName].mockImplementation(implementation);
+	} else if (mockName in mockLinkParser) {
+		(mockLinkParser as any)[mockName].mockImplementation(implementation);
+	}
+}
+
+// Helper to setup mock return values
+export function setupMockReturnValue(
+	mockName: keyof typeof mockFileOperations | keyof typeof mockLinkParser,
+	value: any
+) {
+	if (mockName in mockFileOperations) {
+		(mockFileOperations as any)[mockName].mockReturnValue(value);
+	} else if (mockName in mockLinkParser) {
+		(mockLinkParser as any)[mockName].mockReturnValue(value);
+	}
+}
+
+// Helper to verify mock calls
+export function verifyMockCalls(
+	mockName: keyof typeof mockFileOperations | keyof typeof mockLinkParser,
+	expectedCalls: any[][]
+) {
+	const mock =
+		mockName in mockFileOperations
+			? (mockFileOperations as any)[mockName]
+			: (mockLinkParser as any)[mockName];
+
+	expect(mock).toHaveBeenCalledTimes(expectedCalls.length);
+	expectedCalls.forEach((args, index) => {
+		expect(mock).toHaveBeenNthCalledWith(index + 1, ...args);
+	});
+}

package/src/testing/setup.ts

@@ -0,0 +1,19 @@
+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();
+	};
+}

package/dist/core/evaluator-base.d.ts

@@ -1,52 +0,0 @@
-import type { BehaviorSubject } from "rxjs";
-export interface BaseRule {
-    id: string;
-    expression: string;
-    enabled: boolean;
-}
-/**
- * Generic base class for evaluating JavaScript expressions against frontmatter objects.
- * Provides reactive compilation of rules via RxJS subscription and safe evaluation.
- */
-export declare abstract class BaseEvaluator<TRule extends BaseRule, TSettings> {
-    protected compiledRules: Array<TRule & {
-        fn: (frontmatter: Record<string, unknown>) => boolean;
-    }>;
-    private settingsSubscription;
-    constructor(settingsStore: BehaviorSubject<TSettings>);
-    /**
-     * Extract rules from settings object. Must be implemented by subclasses.
-     */
-    protected abstract extractRules(settings: TSettings): TRule[];
-    /**
-     * Compile rules into executable functions with error handling.
-     */
-    private compileRules;
-    /**
-     * Evaluate a single rule against frontmatter. Returns the result or undefined if error.
-     */
-    protected evaluateRule(rule: TRule & {
-        fn: (frontmatter: Record<string, unknown>) => boolean;
-    }, frontmatter: Record<string, unknown>): boolean | undefined;
-    /**
-     * Convert evaluation result to boolean - only explicit true is considered truthy.
-     */
-    protected isTruthy(result: boolean | undefined): boolean;
-    /**
-     * Clean up subscriptions and compiled rules.
-     */
-    destroy(): void;
-    /**
-     * Get the number of active (compiled) rules.
-     */
-    getActiveRuleCount(): number;
-    /**
-     * Get information about all rules including their validity.
-     */
-    getRuleInfo(): Array<{
-        expression: string;
-        isValid: boolean;
-        enabled: boolean;
-    }>;
-}
-//# sourceMappingURL=evaluator-base.d.ts.map

package/dist/core/evaluator-base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"evaluator-base.d.ts","sourceRoot":"","sources":["../../src/core/evaluator-base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,MAAM,CAAC;AAE1D,MAAM,WAAW,QAAQ;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CACjB;AAED;;;GAGG;AACH,8BAAsB,aAAa,CAAC,KAAK,SAAS,QAAQ,EAAE,SAAS;IACpE,SAAS,CAAC,aAAa,EAAE,KAAK,CAC7B,KAAK,GAAG;QAAE,EAAE,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAA;KAAE,CACjE,CAAM;IACP,OAAO,CAAC,oBAAoB,CAA6B;gBAE7C,aAAa,EAAE,eAAe,CAAC,SAAS,CAAC;IAUrD;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,QAAQ,EAAE,SAAS,GAAG,KAAK,EAAE;IAE7D;;OAEG;IACH,OAAO,CAAC,YAAY;IA6BpB;;OAEG;IACH,SAAS,CAAC,YAAY,CACrB,IAAI,EAAE,KAAK,GAAG;QAAE,EAAE,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAA;KAAE,EACvE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,OAAO,GAAG,SAAS;IAStB;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO;IAIxD;;OAEG;IACH,OAAO,IAAI,IAAI;IAQf;;OAEG;IACH,kBAAkB,IAAI,MAAM;IAI5B;;OAEG;IACH,WAAW,IAAI,KAAK,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CAShF"}

package/dist/core/evaluator-base.js

@@ -1,84 +0,0 @@
-/**
- * Generic base class for evaluating JavaScript expressions against frontmatter objects.
- * Provides reactive compilation of rules via RxJS subscription and safe evaluation.
- */
-export class BaseEvaluator {
-    constructor(settingsStore) {
-        this.compiledRules = [];
-        this.settingsSubscription = null;
-        const initialRules = this.extractRules(settingsStore.value);
-        this.compileRules(initialRules);
-        this.settingsSubscription = settingsStore.subscribe((settings) => {
-            const newRules = this.extractRules(settings);
-            this.compileRules(newRules);
-        });
-    }
-    /**
-     * Compile rules into executable functions with error handling.
-     */
-    compileRules(rules) {
-        this.compiledRules = [];
-        for (const rule of rules) {
-            if (!rule.enabled || !rule.expression.trim())
-                continue;
-            try {
-                const cleanExpression = rule.expression.trim();
-                // Create a function that takes 'fm' (frontmatter) as parameter
-                // and evaluates the expression in that context
-                const fn = new Function("fm", `return (${cleanExpression});`);
-                // Test the function with a dummy object to catch syntax errors early
-                fn({});
-                this.compiledRules.push(Object.assign(Object.assign({}, rule), { expression: cleanExpression, fn }));
-            }
-            catch (error) {
-                console.warn(`Invalid rule expression "${rule.expression}":`, error);
-            }
-        }
-    }
-    /**
-     * Evaluate a single rule against frontmatter. Returns the result or undefined if error.
-     */
-    evaluateRule(rule, frontmatter) {
-        try {
-            return rule.fn(frontmatter);
-        }
-        catch (error) {
-            console.warn(`Error evaluating rule "${rule.expression}":`, error);
-            return undefined;
-        }
-    }
-    /**
-     * Convert evaluation result to boolean - only explicit true is considered truthy.
-     */
-    isTruthy(result) {
-        return result === true;
-    }
-    /**
-     * Clean up subscriptions and compiled rules.
-     */
-    destroy() {
-        if (this.settingsSubscription) {
-            this.settingsSubscription.unsubscribe();
-            this.settingsSubscription = null;
-        }
-        this.compiledRules = [];
-    }
-    /**
-     * Get the number of active (compiled) rules.
-     */
-    getActiveRuleCount() {
-        return this.compiledRules.length;
-    }
-    /**
-     * Get information about all rules including their validity.
-     */
-    getRuleInfo() {
-        const validExpressions = new Set(this.compiledRules.map((r) => r.expression));
-        return this.compiledRules.map((rule) => ({
-            expression: rule.expression,
-            isValid: validExpressions.has(rule.expression),
-            enabled: rule.enabled,
-        }));
-    }
-}
-//# sourceMappingURL=evaluator-base.js.map

package/dist/core/evaluator-base.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"evaluator-base.js","sourceRoot":"","sources":["../../src/core/evaluator-base.ts"],"names":[],"mappings":"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","sourcesContent":["import type { BehaviorSubject, Subscription } from \"rxjs\";\n\nexport interface BaseRule {\n\tid: string;\n\texpression: string;\n\tenabled: boolean;\n}\n\n/**\n * Generic base class for evaluating JavaScript expressions against frontmatter objects.\n * Provides reactive compilation of rules via RxJS subscription and safe evaluation.\n */\nexport abstract class BaseEvaluator<TRule extends BaseRule, TSettings> {\n\tprotected compiledRules: Array<\n\t\tTRule & { fn: (frontmatter: Record<string, unknown>) => boolean }\n\t> = [];\n\tprivate settingsSubscription: Subscription | null = null;\n\n\tconstructor(settingsStore: BehaviorSubject<TSettings>) {\n\t\tconst initialRules = this.extractRules(settingsStore.value);\n\t\tthis.compileRules(initialRules);\n\n\t\tthis.settingsSubscription = settingsStore.subscribe((settings) => {\n\t\t\tconst newRules = this.extractRules(settings);\n\t\t\tthis.compileRules(newRules);\n\t\t});\n\t}\n\n\t/**\n\t * Extract rules from settings object. Must be implemented by subclasses.\n\t */\n\tprotected abstract extractRules(settings: TSettings): TRule[];\n\n\t/**\n\t * Compile rules into executable functions with error handling.\n\t */\n\tprivate compileRules(rules: TRule[]): void {\n\t\tthis.compiledRules = [];\n\n\t\tfor (const rule of rules) {\n\t\t\tif (!rule.enabled || !rule.expression.trim()) continue;\n\n\t\t\ttry {\n\t\t\t\tconst cleanExpression = rule.expression.trim();\n\n\t\t\t\t// Create a function that takes 'fm' (frontmatter) as parameter\n\t\t\t\t// and evaluates the expression in that context\n\t\t\t\tconst fn = new Function(\"fm\", `return (${cleanExpression});`) as (\n\t\t\t\t\tfrontmatter: Record<string, unknown>\n\t\t\t\t) => boolean;\n\n\t\t\t\t// Test the function with a dummy object to catch syntax errors early\n\t\t\t\tfn({});\n\n\t\t\t\tthis.compiledRules.push({\n\t\t\t\t\t...rule,\n\t\t\t\t\texpression: cleanExpression,\n\t\t\t\t\tfn,\n\t\t\t\t});\n\t\t\t} catch (error) {\n\t\t\t\tconsole.warn(`Invalid rule expression \"${rule.expression}\":`, error);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Evaluate a single rule against frontmatter. Returns the result or undefined if error.\n\t */\n\tprotected evaluateRule(\n\t\trule: TRule & { fn: (frontmatter: Record<string, unknown>) => boolean },\n\t\tfrontmatter: Record<string, unknown>\n\t): boolean | undefined {\n\t\ttry {\n\t\t\treturn rule.fn(frontmatter);\n\t\t} catch (error) {\n\t\t\tconsole.warn(`Error evaluating rule \"${rule.expression}\":`, error);\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\t/**\n\t * Convert evaluation result to boolean - only explicit true is considered truthy.\n\t */\n\tprotected isTruthy(result: boolean | undefined): boolean {\n\t\treturn result === true;\n\t}\n\n\t/**\n\t * Clean up subscriptions and compiled rules.\n\t */\n\tdestroy(): void {\n\t\tif (this.settingsSubscription) {\n\t\t\tthis.settingsSubscription.unsubscribe();\n\t\t\tthis.settingsSubscription = null;\n\t\t}\n\t\tthis.compiledRules = [];\n\t}\n\n\t/**\n\t * Get the number of active (compiled) rules.\n\t */\n\tgetActiveRuleCount(): number {\n\t\treturn this.compiledRules.length;\n\t}\n\n\t/**\n\t * Get information about all rules including their validity.\n\t */\n\tgetRuleInfo(): Array<{ expression: string; isValid: boolean; enabled: boolean }> {\n\t\tconst validExpressions = new Set(this.compiledRules.map((r) => r.expression));\n\n\t\treturn this.compiledRules.map((rule) => ({\n\t\t\texpression: rule.expression,\n\t\t\tisValid: validExpressions.has(rule.expression),\n\t\t\tenabled: rule.enabled,\n\t\t}));\n\t}\n}\n"]}