@real1ty-obsidian-plugins/utils 2.5.0 → 2.7.0

package/src/file/property-utils.ts

@@ -0,0 +1,114 @@
+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: string | string[] | undefined,
+	linkPath: string
+): string[] {
+	// 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: string | string[] | undefined,
+	linkPath: string
+): string[] {
+	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: string | string[] | undefined,
+	linkPath: string
+): boolean {
+	const existingPaths = parsePropertyLinks(currentValue);
+
+	const normalizedLinkPath = normalizePath(linkPath);
+
+	return existingPaths.some((path) => normalizePath(path) === normalizedLinkPath);
+}

package/src/index.ts

@@ -9,6 +9,8 @@ export * from "./core";
 export * from "./date";
 // File operations
 export * from "./file";
+// Input utilities
+export * from "./inputs";
 export * from "./settings";
 // String utilities
 export * from "./string";

package/src/inputs/index.ts

@@ -0,0 +1 @@
+export * from "./input-filter-manager";

package/src/inputs/input-filter-manager.ts

@@ -0,0 +1,194 @@
+export type FilterChangeCallback = (filterValue: string) => void;
+
+const DEFAULT_DEBOUNCE_MS = 150;
+
+export interface InputFilterManagerOptions {
+	placeholder: string;
+	cssClass: string;
+	cssPrefix: string;
+	onFilterChange: FilterChangeCallback;
+	initiallyVisible?: boolean;
+	onHide?: () => void;
+	debounceMs?: number;
+}
+
+/**
+ * Abstract base class for managing input-based filters with debouncing.
+ * Provides a reusable pattern for filter inputs with show/hide functionality,
+ * keyboard shortcuts, and debounced updates.
+ *
+ * @template T - The type of data being filtered (optional, defaults to unknown)
+ *
+ * @example
+ * ```ts
+ * class MyFilterManager extends InputFilterManager<MyDataType> {
+ *   shouldInclude(data: MyDataType): boolean {
+ *     const filter = this.getCurrentValue().toLowerCase();
+ *     return data.name.toLowerCase().includes(filter);
+ *   }
+ * }
+ *
+ * const manager = new MyFilterManager(
+ *   containerEl,
+ *   {
+ *     placeholder: "Filter items...",
+ *     cssClass: "my-filter-input",
+ *     onFilterChange: (value) => console.log("Filter changed:", value),
+ *     initiallyVisible: false,
+ *   }
+ * );
+ * ```
+ */
+export abstract class InputFilterManager<T> {
+	protected containerEl: HTMLElement;
+	protected inputEl: HTMLInputElement | null = null;
+	protected debounceTimer: number | null = null;
+	protected currentValue = "";
+	protected persistentlyVisible = false;
+	protected onHide?: () => void;
+	protected readonly debounceMs: number;
+	protected readonly placeholder: string;
+	protected readonly cssClass: string;
+	protected readonly cssPrefix: string;
+	protected readonly onFilterChange: FilterChangeCallback;
+
+	constructor(
+		protected parentEl: HTMLElement,
+		options: InputFilterManagerOptions
+	) {
+		const {
+			placeholder,
+			cssClass,
+			cssPrefix,
+			onFilterChange,
+			initiallyVisible = false,
+			onHide,
+			debounceMs = DEFAULT_DEBOUNCE_MS,
+		} = options;
+
+		this.debounceMs = debounceMs;
+		this.placeholder = placeholder;
+		this.cssClass = cssClass;
+		this.cssPrefix = cssPrefix;
+		this.onFilterChange = onFilterChange;
+		this.onHide = onHide;
+
+		const classes = `${cssClass}-container${initiallyVisible ? "" : ` ${cssPrefix}-hidden`}`;
+		this.containerEl = this.parentEl.createEl("div", {
+			cls: classes,
+		});
+
+		this.render();
+	}
+
+	private render(): void {
+		this.inputEl = this.containerEl.createEl("input", {
+			type: "text",
+			cls: this.cssClass,
+			placeholder: this.placeholder,
+		});
+
+		this.inputEl.addEventListener("input", () => {
+			this.handleInputChange();
+		});
+
+		this.inputEl.addEventListener("keydown", (evt) => {
+			if (evt.key === "Escape") {
+				// Only allow hiding if not persistently visible
+				if (!this.persistentlyVisible) {
+					this.hide();
+				} else {
+					// Just blur the input if persistently visible
+					this.inputEl?.blur();
+				}
+			} else if (evt.key === "Enter") {
+				this.applyFilterImmediately();
+			}
+		});
+	}
+
+	private handleInputChange(): void {
+		if (this.debounceTimer !== null) {
+			window.clearTimeout(this.debounceTimer);
+		}
+
+		this.debounceTimer = window.setTimeout(() => {
+			this.applyFilterImmediately();
+		}, this.debounceMs);
+	}
+
+	private applyFilterImmediately(): void {
+		const newValue = this.inputEl?.value.trim() ?? "";
+
+		if (newValue !== this.currentValue) {
+			this.updateFilterValue(newValue);
+		}
+	}
+
+	protected updateFilterValue(value: string): void {
+		this.currentValue = value;
+		this.onFilterChange(value);
+	}
+
+	getCurrentValue(): string {
+		return this.currentValue;
+	}
+
+	show(): void {
+		this.containerEl.removeClass(`${this.cssPrefix}-hidden`);
+		this.inputEl?.focus();
+	}
+
+	hide(): void {
+		// Don't allow hiding if persistently visible
+		if (this.persistentlyVisible) {
+			return;
+		}
+
+		this.containerEl.addClass(`${this.cssPrefix}-hidden`);
+
+		if (this.inputEl) {
+			this.inputEl.value = "";
+		}
+
+		this.updateFilterValue("");
+		this.onHide?.();
+	}
+
+	focus(): void {
+		this.inputEl?.focus();
+	}
+
+	isVisible(): boolean {
+		return !this.containerEl.hasClass(`${this.cssPrefix}-hidden`);
+	}
+
+	setPersistentlyVisible(value: boolean): void {
+		this.persistentlyVisible = value;
+
+		if (value) {
+			this.show();
+		} else {
+			this.hide();
+		}
+	}
+
+	destroy(): void {
+		if (this.debounceTimer !== null) {
+			window.clearTimeout(this.debounceTimer);
+			this.debounceTimer = null;
+		}
+
+		this.containerEl.remove();
+		this.inputEl = null;
+	}
+
+	/**
+	 * Abstract method that subclasses must implement to determine
+	 * whether a data item should be included based on the current filter.
+	 *
+	 * @param data - The data item to check
+	 * @returns True if the item should be included, false otherwise
+	 */
+	abstract shouldInclude(data: T): boolean;
+}