@real1ty-obsidian-plugins/utils 2.4.0 → 2.6.0

package/dist/file/property-utils.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Adds a link to a property, avoiding duplicates using normalized path comparison.
+ * Prevents cycles and duplicate relationships by comparing normalized paths.
+ *
+ * **Important**: linkPath should be WITHOUT .md extension (wikilink format).
+ *
+ * @param currentValue - The current property value (can be string, string[], or undefined)
+ * @param linkPath - The file path to add (without .md extension, e.g., "folder/file")
+ * @returns New array with link added, or same array if link already exists
+ *
+ * @example
+ * ```ts
+ * addLinkToProperty(undefined, "MyNote") // ["[[MyNote]]"]
+ * addLinkToProperty("[[Note1]]", "Note2") // ["[[Note1]]", "[[Note2]]"]
+ * addLinkToProperty(["[[Note1]]"], "Note2") // ["[[Note1]]", "[[Note2]]"]
+ * addLinkToProperty(["[[Note1]]"], "Note1") // ["[[Note1]]"] (no change - duplicate prevented)
+ * addLinkToProperty(["[[Folder/Note]]"], "folder/note") // ["[[Folder/Note]]", "[[folder/note|note]]"] (case-sensitive, different entry)
+ * ```
+ */
+export declare function addLinkToProperty(currentValue: string | string[] | undefined, linkPath: string): string[];
+/**
+ * Removes a link from a property using normalized path comparison.
+ *
+ * @param currentValue - The current property value (can be string, string[], or undefined)
+ * @param linkPath - The file path to remove (without .md extension)
+ * @returns New array with link removed (can be empty)
+ *
+ * @example
+ * ```ts
+ * removeLinkFromProperty(["[[Note1]]", "[[Note2]]"], "Note1") // ["[[Note2]]"]
+ * removeLinkFromProperty(["[[Note1]]"], "Note1") // []
+ * removeLinkFromProperty("[[Note1]]", "Note1") // []
+ * removeLinkFromProperty(undefined, "Note1") // []
+ * removeLinkFromProperty(["[[Folder/Note]]"], "Folder/Note") // [] (case-sensitive removal)
+ * ```
+ */
+export declare function removeLinkFromProperty(currentValue: string | string[] | undefined, linkPath: string): string[];
+/**
+ * Checks if a link exists in a property using normalized path comparison.
+ *
+ * @param currentValue - The current property value (can be string, string[], or undefined)
+ * @param linkPath - The file path to check (without .md extension)
+ * @returns True if the link exists
+ *
+ * @example
+ * ```ts
+ * hasLinkInProperty(["[[Note1]]", "[[Note2]]"], "Note1") // true
+ * hasLinkInProperty("[[Note1]]", "Note1") // true
+ * hasLinkInProperty([], "Note1") // false
+ * hasLinkInProperty(undefined, "Note1") // false
+ * hasLinkInProperty(["[[Folder/Note]]"], "Folder/Note") // true (case-sensitive match)
+ * ```
+ */
+export declare function hasLinkInProperty(currentValue: string | string[] | undefined, linkPath: string): boolean;
+//# sourceMappingURL=property-utils.d.ts.map

package/dist/file/property-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"property-utils.d.ts","sourceRoot":"","sources":["../../src/file/property-utils.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAChC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,EAC3C,QAAQ,EAAE,MAAM,GACd,MAAM,EAAE,CAsBV;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CACrC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,EAC3C,QAAQ,EAAE,MAAM,GACd,MAAM,EAAE,CAiBV;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAChC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,EAC3C,QAAQ,EAAE,MAAM,GACd,OAAO,CAMT"}

package/dist/file/property-utils.js

@@ -0,0 +1,90 @@
+import { normalizePath } from "obsidian";
+import { formatWikiLink, parsePropertyLinks } from "./link-parser";
+/**
+ * Adds a link to a property, avoiding duplicates using normalized path comparison.
+ * Prevents cycles and duplicate relationships by comparing normalized paths.
+ *
+ * **Important**: linkPath should be WITHOUT .md extension (wikilink format).
+ *
+ * @param currentValue - The current property value (can be string, string[], or undefined)
+ * @param linkPath - The file path to add (without .md extension, e.g., "folder/file")
+ * @returns New array with link added, or same array if link already exists
+ *
+ * @example
+ * ```ts
+ * addLinkToProperty(undefined, "MyNote") // ["[[MyNote]]"]
+ * addLinkToProperty("[[Note1]]", "Note2") // ["[[Note1]]", "[[Note2]]"]
+ * addLinkToProperty(["[[Note1]]"], "Note2") // ["[[Note1]]", "[[Note2]]"]
+ * addLinkToProperty(["[[Note1]]"], "Note1") // ["[[Note1]]"] (no change - duplicate prevented)
+ * addLinkToProperty(["[[Folder/Note]]"], "folder/note") // ["[[Folder/Note]]", "[[folder/note|note]]"] (case-sensitive, different entry)
+ * ```
+ */
+export function addLinkToProperty(currentValue, linkPath) {
+    // Handle undefined or null
+    if (currentValue === undefined || currentValue === null) {
+        return [formatWikiLink(linkPath)];
+    }
+    // Normalize to array
+    const currentArray = Array.isArray(currentValue) ? currentValue : [currentValue];
+    const existingPaths = parsePropertyLinks(currentArray);
+    // Normalize paths for comparison to prevent duplicates with different casing or separators
+    const normalizedLinkPath = normalizePath(linkPath);
+    const normalizedExistingPaths = existingPaths.map((p) => normalizePath(p));
+    // Only add if not already present (using normalized path comparison)
+    if (!normalizedExistingPaths.includes(normalizedLinkPath)) {
+        return [...currentArray, formatWikiLink(linkPath)];
+    }
+    return currentArray;
+}
+/**
+ * Removes a link from a property using normalized path comparison.
+ *
+ * @param currentValue - The current property value (can be string, string[], or undefined)
+ * @param linkPath - The file path to remove (without .md extension)
+ * @returns New array with link removed (can be empty)
+ *
+ * @example
+ * ```ts
+ * removeLinkFromProperty(["[[Note1]]", "[[Note2]]"], "Note1") // ["[[Note2]]"]
+ * removeLinkFromProperty(["[[Note1]]"], "Note1") // []
+ * removeLinkFromProperty("[[Note1]]", "Note1") // []
+ * removeLinkFromProperty(undefined, "Note1") // []
+ * removeLinkFromProperty(["[[Folder/Note]]"], "Folder/Note") // [] (case-sensitive removal)
+ * ```
+ */
+export function removeLinkFromProperty(currentValue, linkPath) {
+    if (currentValue === undefined || currentValue === null) {
+        return [];
+    }
+    // Normalize to array
+    const currentArray = Array.isArray(currentValue) ? currentValue : [currentValue];
+    const normalizedLinkPath = normalizePath(linkPath);
+    return currentArray.filter((item) => {
+        const parsed = parsePropertyLinks([item])[0];
+        if (!parsed)
+            return true; // Keep invalid entries
+        return normalizePath(parsed) !== normalizedLinkPath;
+    });
+}
+/**
+ * Checks if a link exists in a property using normalized path comparison.
+ *
+ * @param currentValue - The current property value (can be string, string[], or undefined)
+ * @param linkPath - The file path to check (without .md extension)
+ * @returns True if the link exists
+ *
+ * @example
+ * ```ts
+ * hasLinkInProperty(["[[Note1]]", "[[Note2]]"], "Note1") // true
+ * hasLinkInProperty("[[Note1]]", "Note1") // true
+ * hasLinkInProperty([], "Note1") // false
+ * hasLinkInProperty(undefined, "Note1") // false
+ * hasLinkInProperty(["[[Folder/Note]]"], "Folder/Note") // true (case-sensitive match)
+ * ```
+ */
+export function hasLinkInProperty(currentValue, linkPath) {
+    const existingPaths = parsePropertyLinks(currentValue);
+    const normalizedLinkPath = normalizePath(linkPath);
+    return existingPaths.some((path) => normalizePath(path) === normalizedLinkPath);
+}
+//# sourceMappingURL=property-utils.js.map

package/dist/file/property-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"property-utils.js","sourceRoot":"","sources":["../../src/file/property-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAEnE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,iBAAiB,CAChC,YAA2C,EAC3C,QAAgB;IAEhB,2BAA2B;IAC3B,IAAI,YAAY,KAAK,SAAS,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;QACzD,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC;IACnC,CAAC;IAED,qBAAqB;IACrB,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;IAEjF,MAAM,aAAa,GAAG,kBAAkB,CAAC,YAAY,CAAC,CAAC;IAEvD,2FAA2F;IAC3F,MAAM,kBAAkB,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAC;IAEnD,MAAM,uBAAuB,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IAE3E,qEAAqE;IACrE,IAAI,CAAC,uBAAuB,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC;QAC3D,OAAO,CAAC,GAAG,YAAY,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC;IACpD,CAAC;IAED,OAAO,YAAY,CAAC;AACrB,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,sBAAsB,CACrC,YAA2C,EAC3C,QAAgB;IAEhB,IAAI,YAAY,KAAK,SAAS,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;QACzD,OAAO,EAAE,CAAC;IACX,CAAC;IAED,qBAAqB;IACrB,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;IAEjF,MAAM,kBAAkB,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAC;IAEnD,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;QACnC,MAAM,MAAM,GAAG,kBAAkB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAE7C,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,CAAC,uBAAuB;QAEjD,OAAO,aAAa,CAAC,MAAM,CAAC,KAAK,kBAAkB,CAAC;IACrD,CAAC,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,iBAAiB,CAChC,YAA2C,EAC3C,QAAgB;IAEhB,MAAM,aAAa,GAAG,kBAAkB,CAAC,YAAY,CAAC,CAAC;IAEvD,MAAM,kBAAkB,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAC;IAEnD,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,kBAAkB,CAAC,CAAC;AACjF,CAAC","sourcesContent":["import { normalizePath } from \"obsidian\";\n\nimport { formatWikiLink, parsePropertyLinks } from \"./link-parser\";\n\n/**\n * Adds a link to a property, avoiding duplicates using normalized path comparison.\n * Prevents cycles and duplicate relationships by comparing normalized paths.\n *\n * **Important**: linkPath should be WITHOUT .md extension (wikilink format).\n *\n * @param currentValue - The current property value (can be string, string[], or undefined)\n * @param linkPath - The file path to add (without .md extension, e.g., \"folder/file\")\n * @returns New array with link added, or same array if link already exists\n *\n * @example\n * ```ts\n * addLinkToProperty(undefined, \"MyNote\") // [\"[[MyNote]]\"]\n * addLinkToProperty(\"[[Note1]]\", \"Note2\") // [\"[[Note1]]\", \"[[Note2]]\"]\n * addLinkToProperty([\"[[Note1]]\"], \"Note2\") // [\"[[Note1]]\", \"[[Note2]]\"]\n * addLinkToProperty([\"[[Note1]]\"], \"Note1\") // [\"[[Note1]]\"] (no change - duplicate prevented)\n * addLinkToProperty([\"[[Folder/Note]]\"], \"folder/note\") // [\"[[Folder/Note]]\", \"[[folder/note|note]]\"] (case-sensitive, different entry)\n * ```\n */\nexport function addLinkToProperty(\n\tcurrentValue: string | string[] | undefined,\n\tlinkPath: string\n): string[] {\n\t// Handle undefined or null\n\tif (currentValue === undefined || currentValue === null) {\n\t\treturn [formatWikiLink(linkPath)];\n\t}\n\n\t// Normalize to array\n\tconst currentArray = Array.isArray(currentValue) ? currentValue : [currentValue];\n\n\tconst existingPaths = parsePropertyLinks(currentArray);\n\n\t// Normalize paths for comparison to prevent duplicates with different casing or separators\n\tconst normalizedLinkPath = normalizePath(linkPath);\n\n\tconst normalizedExistingPaths = existingPaths.map((p) => normalizePath(p));\n\n\t// Only add if not already present (using normalized path comparison)\n\tif (!normalizedExistingPaths.includes(normalizedLinkPath)) {\n\t\treturn [...currentArray, formatWikiLink(linkPath)];\n\t}\n\n\treturn currentArray;\n}\n\n/**\n * Removes a link from a property using normalized path comparison.\n *\n * @param currentValue - The current property value (can be string, string[], or undefined)\n * @param linkPath - The file path to remove (without .md extension)\n * @returns New array with link removed (can be empty)\n *\n * @example\n * ```ts\n * removeLinkFromProperty([\"[[Note1]]\", \"[[Note2]]\"], \"Note1\") // [\"[[Note2]]\"]\n * removeLinkFromProperty([\"[[Note1]]\"], \"Note1\") // []\n * removeLinkFromProperty(\"[[Note1]]\", \"Note1\") // []\n * removeLinkFromProperty(undefined, \"Note1\") // []\n * removeLinkFromProperty([\"[[Folder/Note]]\"], \"Folder/Note\") // [] (case-sensitive removal)\n * ```\n */\nexport function removeLinkFromProperty(\n\tcurrentValue: string | string[] | undefined,\n\tlinkPath: string\n): string[] {\n\tif (currentValue === undefined || currentValue === null) {\n\t\treturn [];\n\t}\n\n\t// Normalize to array\n\tconst currentArray = Array.isArray(currentValue) ? currentValue : [currentValue];\n\n\tconst normalizedLinkPath = normalizePath(linkPath);\n\n\treturn currentArray.filter((item) => {\n\t\tconst parsed = parsePropertyLinks([item])[0];\n\n\t\tif (!parsed) return true; // Keep invalid entries\n\n\t\treturn normalizePath(parsed) !== normalizedLinkPath;\n\t});\n}\n\n/**\n * Checks if a link exists in a property using normalized path comparison.\n *\n * @param currentValue - The current property value (can be string, string[], or undefined)\n * @param linkPath - The file path to check (without .md extension)\n * @returns True if the link exists\n *\n * @example\n * ```ts\n * hasLinkInProperty([\"[[Note1]]\", \"[[Note2]]\"], \"Note1\") // true\n * hasLinkInProperty(\"[[Note1]]\", \"Note1\") // true\n * hasLinkInProperty([], \"Note1\") // false\n * hasLinkInProperty(undefined, \"Note1\") // false\n * hasLinkInProperty([\"[[Folder/Note]]\"], \"Folder/Note\") // true (case-sensitive match)\n * ```\n */\nexport function hasLinkInProperty(\n\tcurrentValue: string | string[] | undefined,\n\tlinkPath: string\n): boolean {\n\tconst existingPaths = parsePropertyLinks(currentValue);\n\n\tconst normalizedLinkPath = normalizePath(linkPath);\n\n\treturn existingPaths.some((path) => normalizePath(path) === normalizedLinkPath);\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@real1ty-obsidian-plugins/utils",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "description": "Shared utilities for Obsidian plugins",
   "type": "module",
   "main": "./dist/index.js",
@@ -44,6 +44,7 @@
   },
   "devDependencies": {
     "@types/luxon": "^3.7.1",
+    "fast-check": "^4.3.0",
     "typescript": "5.9.2",
     "vitest": "^2.0.5"
   },

package/src/core/evaluator/base.ts

@@ -0,0 +1,71 @@
+import type { BehaviorSubject, Subscription } from "rxjs";
+
+import { buildPropertyMapping, sanitizeExpression } from "../expression-utils";
+
+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 abstract class BaseEvaluator<TRule extends BaseRule, TSettings> {
+	protected rules: TRule[] = [];
+	private compiledFunctions = new Map<string, ((...args: any[]) => boolean) | null>();
+	private propertyMapping = new Map<string, string>();
+	private subscription: Subscription | null = null;
+
+	constructor(settingsStore: BehaviorSubject<TSettings>) {
+		this.subscription = settingsStore.subscribe((settings) => {
+			this.rules = this.extractRules(settings);
+			this.compiledFunctions.clear();
+			this.propertyMapping.clear();
+		});
+	}
+
+	protected abstract extractRules(settings: TSettings): TRule[];
+
+	destroy(): void {
+		this.subscription?.unsubscribe();
+		this.compiledFunctions.clear();
+		this.propertyMapping.clear();
+	}
+
+	protected evaluateRule(rule: TRule, frontmatter: Record<string, unknown>): boolean {
+		if (!rule.enabled || !rule.expression) {
+			return false;
+		}
+
+		try {
+			if (this.propertyMapping.size === 0) {
+				this.propertyMapping = buildPropertyMapping(Object.keys(frontmatter));
+			}
+
+			let compiledFunc = this.compiledFunctions.get(rule.id);
+
+			if (!compiledFunc) {
+				const sanitized = sanitizeExpression(rule.expression, this.propertyMapping);
+				const params = Array.from(this.propertyMapping.values());
+				compiledFunc = new Function(...params, `"use strict"; return ${sanitized};`) as (
+					...args: any[]
+				) => boolean;
+				this.compiledFunctions.set(rule.id, compiledFunc);
+			}
+
+			const values = Array.from(this.propertyMapping.keys()).map((key) => frontmatter[key]);
+			const result = compiledFunc(...values);
+
+			return result === true;
+		} catch (error) {
+			console.warn(`Invalid expression (${rule.id}):`, rule.expression, error);
+			return false;
+		}
+	}
+
+	protected isTruthy(value: any): boolean {
+		return value === true;
+	}
+}

package/src/core/evaluator/color.ts

@@ -0,0 +1,37 @@
+import type { BehaviorSubject } from "rxjs";
+
+import { BaseEvaluator, type BaseRule } from "./base";
+
+export interface ColorRule extends BaseRule {
+	color: string;
+}
+
+/**
+ * Generic evaluator for determining colors based on frontmatter rules.
+ * Extends BaseEvaluator to evaluate color rules against frontmatter.
+ */
+export class ColorEvaluator<
+	TSettings extends { defaultNodeColor: string; colorRules: ColorRule[] },
+> extends BaseEvaluator<ColorRule, TSettings> {
+	private defaultColor: string;
+
+	constructor(settingsStore: BehaviorSubject<TSettings>) {
+		super(settingsStore);
+		this.defaultColor = settingsStore.value.defaultNodeColor;
+
+		settingsStore.subscribe((settings) => {
+			if (settings.defaultNodeColor) {
+				this.defaultColor = settings.defaultNodeColor;
+			}
+		});
+	}
+
+	protected extractRules(settings: TSettings): ColorRule[] {
+		return settings.colorRules;
+	}
+
+	evaluateColor(frontmatter: Record<string, unknown>): string {
+		const match = this.rules.find((rule) => this.isTruthy(this.evaluateRule(rule, frontmatter)));
+		return match?.color ?? this.defaultColor;
+	}
+}

package/src/core/evaluator/excluded.ts

@@ -0,0 +1,63 @@
+import type { BehaviorSubject } from "rxjs";
+
+export interface PathExcludedProperties {
+	id: string;
+	path: string;
+	excludedProperties: string[];
+	enabled: boolean;
+}
+
+/**
+ * Generic evaluator for determining which frontmatter properties to exclude when creating new nodes.
+ *
+ * Logic:
+ * 1. ALWAYS includes the default excluded properties (e.g., Parent, Child, Related, _ZettelID)
+ * 2. Checks if the source file's path matches any path-based exclusion rules
+ * 3. First matching path rule's properties are ADDED to the default exclusion list
+ * 4. Returns the combined set of excluded properties
+ */
+export class ExcludedPropertiesEvaluator<
+	TSettings extends {
+		defaultExcludedProperties: string[];
+		pathExcludedProperties: PathExcludedProperties[];
+	},
+> {
+	private defaultExcludedProperties: string[];
+
+	private pathRules: PathExcludedProperties[];
+
+	constructor(settingsObservable: BehaviorSubject<TSettings>) {
+		const assignSettings = (settings: TSettings) => {
+			this.defaultExcludedProperties = settings.defaultExcludedProperties;
+			this.pathRules = settings.pathExcludedProperties.filter((rule) => rule.enabled);
+		};
+
+		assignSettings(settingsObservable.value);
+		settingsObservable.subscribe(assignSettings);
+	}
+
+	/**
+	 * Evaluate which properties should be excluded for a given file path.
+	 *
+	 * @param filePath - The file path to match against path rules
+	 * @returns Array of property names to exclude (always includes defaults + path rule matches)
+	 */
+	evaluateExcludedProperties(filePath: string): string[] {
+		// Always start with default excluded properties
+		const excludedProperties = [...this.defaultExcludedProperties];
+
+		// Find first matching path rule and add its excluded properties
+		const match = this.pathRules.find((rule) => filePath.startsWith(rule.path));
+
+		if (match) {
+			// Add path-specific excluded properties to the defaults
+			for (const prop of match.excludedProperties) {
+				if (!excludedProperties.includes(prop)) {
+					excludedProperties.push(prop);
+				}
+			}
+		}
+
+		return excludedProperties;
+	}
+}

package/src/core/evaluator/filter.ts

@@ -0,0 +1,33 @@
+import { BaseEvaluator, type BaseRule } from "./base";
+
+export interface FilterRule extends BaseRule {}
+
+/**
+ * Generic evaluator for filtering based on frontmatter expressions.
+ * Extends BaseEvaluator to evaluate filter rules against frontmatter.
+ * Returns true only if ALL rules evaluate to true.
+ */
+export class FilterEvaluator<
+	TSettings extends { filterExpressions: string[] },
+> extends BaseEvaluator<FilterRule, TSettings> {
+	protected extractRules(settings: TSettings): FilterRule[] {
+		return settings.filterExpressions.map((expression, index) => ({
+			id: `filter-${index}`,
+			expression: expression.trim(),
+			enabled: true,
+		}));
+	}
+
+	evaluateFilters(frontmatter: Record<string, unknown>): boolean {
+		if (this.rules.length === 0) {
+			return true;
+		}
+
+		return this.rules.every((rule) => {
+			if (!rule.enabled || !rule.expression) {
+				return true;
+			}
+			return this.evaluateRule(rule, frontmatter);
+		});
+	}
+}

package/src/core/evaluator/included.ts

@@ -0,0 +1,74 @@
+import type { BehaviorSubject } from "rxjs";
+
+export interface PathIncludedProperties {
+	id: string;
+	path: string;
+	includedProperties: string[];
+	enabled: boolean;
+}
+
+/**
+ * Generic evaluator for determining which properties to include in Bases view columns.
+ *
+ * Logic:
+ * 1. ALWAYS includes the default included properties
+ * 2. Checks if the file's path matches any path-based inclusion rules
+ * 3. First matching path rule's properties are ADDED to the default inclusion list
+ * 4. Returns the combined set of included properties in order:
+ *    - file.name (always first)
+ *    - default included properties (in specified order)
+ *    - path-specific included properties (in specified order)
+ */
+export class IncludedPropertiesEvaluator<
+	TSettings extends {
+		defaultBasesIncludedProperties: string[];
+		pathBasesIncludedProperties: PathIncludedProperties[];
+	},
+> {
+	private defaultIncludedProperties: string[];
+
+	private pathRules: PathIncludedProperties[];
+
+	constructor(settingsObservable: BehaviorSubject<TSettings>) {
+		const assignSettings = (settings: TSettings) => {
+			this.defaultIncludedProperties = settings.defaultBasesIncludedProperties;
+			this.pathRules = settings.pathBasesIncludedProperties.filter((rule) => rule.enabled);
+		};
+
+		assignSettings(settingsObservable.value);
+		settingsObservable.subscribe(assignSettings);
+	}
+
+	/**
+	 * Evaluate which properties should be included in the order array for a given file path.
+	 * Returns an array with "file.name" as the first element, followed by default and path-specific properties.
+	 *
+	 * @param filePath - The file path to match against path rules
+	 * @returns Array of property names to include in the order (file.name + defaults + path rule matches)
+	 */
+	evaluateIncludedProperties(filePath: string): string[] {
+		// Always start with file.name
+		const includedProperties = ["file.name"];
+
+		// Add default included properties
+		for (const prop of this.defaultIncludedProperties) {
+			if (!includedProperties.includes(prop)) {
+				includedProperties.push(prop);
+			}
+		}
+
+		// Find first matching path rule and add its included properties
+		const match = this.pathRules.find((rule) => filePath.startsWith(rule.path));
+
+		if (match) {
+			// Add path-specific included properties to the defaults
+			for (const prop of match.includedProperties) {
+				if (!includedProperties.includes(prop)) {
+					includedProperties.push(prop);
+				}
+			}
+		}
+
+		return includedProperties;
+	}
+}

package/src/core/evaluator/index.ts

@@ -0,0 +1,5 @@
+export * from "./base";
+export * from "./color";
+export * from "./excluded";
+export * from "./filter";
+export * from "./included";

package/src/core/expression-utils.ts

@@ -0,0 +1,53 @@
+/**
+ * Sanitizes a property name for use as a JavaScript function parameter
+ * by replacing spaces and special characters with underscores.
+ * Adds a prefix to avoid conflicts with JavaScript reserved words.
+ */
+export function sanitizePropertyName(name: string): string {
+	const sanitized = name.replace(/[^a-zA-Z0-9_]/g, "_");
+	return `prop_${sanitized}`;
+}
+
+/**
+ * Builds a mapping of original property names to sanitized versions
+ * suitable for use as JavaScript function parameters.
+ */
+export function buildPropertyMapping(properties: string[]): Map<string, string> {
+	const mapping = new Map<string, string>();
+
+	for (const prop of properties) {
+		mapping.set(prop, sanitizePropertyName(prop));
+	}
+
+	return mapping;
+}
+
+/**
+ * Replaces property names in an expression with their sanitized versions.
+ * Sorts by length descending to replace longer property names first and avoid partial matches.
+ */
+export function sanitizeExpression(
+	expression: string,
+	propertyMapping: Map<string, string>
+): string {
+	let sanitized = expression;
+
+	// Sort by length descending to replace longer property names first
+	const sortedEntries = Array.from(propertyMapping.entries()).sort(
+		([a], [b]) => b.length - a.length
+	);
+
+	for (const [original, sanitizedName] of sortedEntries) {
+		if (original !== sanitizedName) {
+			const escaped = original.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+			// Use a regex that matches the property name not preceded or followed by word characters
+			// This allows matching properties with special characters like "My-Property"
+			const regex = new RegExp(`(?<!\\w)${escaped}(?!\\w)`, "g");
+
+			sanitized = sanitized.replace(regex, sanitizedName);
+		}
+	}
+
+	return sanitized;
+}