@real1ty-obsidian-plugins/utils 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2025 Dynalist Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,90 @@
+# @real1ty-obsidian-plugins/utils
+
+Shared utilities for Obsidian plugins - a comprehensive collection of reusable functions and helpers to streamline Obsidian plugin development.
+
+## Installation
+
+```bash
+npm install @real1ty-obsidian-plugins/utils
+# or
+pnpm add @real1ty-obsidian-plugins/utils
+# or
+yarn add @real1ty-obsidian-plugins/utils
+```
+
+## Features
+
+- **Date & Time Utilities**: Recurrence handling, date formatting, and time operations
+- **File Operations**: File system helpers, path utilities, and content manipulation
+- **String Utilities**: Text processing, sanitization, and formatting functions
+- **Async Utilities**: Promise helpers and async operation management
+- **Batch Operations**: Efficient bulk processing utilities
+- **Settings Store**: Reactive settings management with RxJS
+- **Testing Utilities**: Mock factories and test helpers for Obsidian plugins
+- **Link Parser**: Markdown link parsing and manipulation
+- **Child Reference Utils**: Hierarchical content reference management
+
+## Usage
+
+```typescript
+import {
+  formatDateTimeForInput,
+  generateUniqueFilePath,
+  SettingsStore
+} from '@real1ty-obsidian-plugins/utils';
+
+// Date utilities
+const formattedDate = formatDateTimeForInput('2023-12-25T10:30:00');
+
+// File operations
+const uniquePath = await generateUniqueFilePath(app, folder, 'my-file');
+
+// Settings management
+const settingsStore = new SettingsStore(defaultSettings);
+settingsStore.settings$.subscribe(settings => {
+  // React to settings changes
+});
+```
+
+### Testing Utilities
+
+For testing your Obsidian plugins:
+
+```typescript
+import {
+  createMockApp,
+  createMockFile,
+  setupTestEnvironment
+} from '@real1ty-obsidian-plugins/utils/testing';
+
+// Set up test environment
+setupTestEnvironment();
+
+// Create mock Obsidian instances
+const mockApp = createMockApp();
+const mockFile = createMockFile('test.md');
+```
+
+## API Reference
+
+### Available Modules
+
+- `async-utils` - Promise utilities and async helpers
+- `batch-operations` - Bulk processing functions
+- `child-reference-utils` - Hierarchical reference management
+- `date-recurrence-utils` - Recurrence pattern handling
+- `date-utils` - Date/time formatting and manipulation
+- `file-operations` - File system operations
+- `file-utils` - File path and content utilities
+- `settings-store` - Reactive settings management
+- `string-utils` - String processing functions
+- `templater-utils` - Template processing utilities
+- `testing` - Testing mocks and utilities
+
+## TypeScript Support
+
+This package is written in TypeScript and includes full type definitions. All utilities are properly typed for the best development experience.
+
+## License
+
+MIT

package/dist/async-utils.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Creates a function that ensures an async operation runs only once,
+ * returning the same promise for concurrent calls.
+ *
+ * Useful for initialization patterns where you want to ensure
+ * expensive async operations (like indexing, API calls, etc.)
+ * only happen once even if called multiple times.
+ *
+ * @param fn The async function to memoize
+ * @returns A function that returns the same promise on subsequent calls
+ *
+ * @example
+ * ```typescript
+ * const initializeOnce = onceAsync(async () => {
+ *   await heavyInitialization();
+ *   console.log("Initialized!");
+ * });
+ *
+ * // All these calls will share the same promise
+ * await initializeOnce();
+ * await initializeOnce(); // Won't run again
+ * await initializeOnce(); // Won't run again
+ * ```
+ */
+export declare function onceAsync<T>(fn: () => Promise<T>): () => Promise<T>;
+/**
+ * Creates a function that ensures an async operation runs only once per key,
+ * useful for caching expensive operations with different parameters.
+ *
+ * @param fn The async function to memoize
+ * @returns A function that memoizes results by key
+ *
+ * @example
+ * ```typescript
+ * const fetchUserOnce = onceAsyncKeyed(async (userId: string) => {
+ *   return await api.getUser(userId);
+ * });
+ *
+ * // Each unique userId will only be fetched once
+ * await fetchUserOnce("user1");
+ * await fetchUserOnce("user1"); // Returns cached promise
+ * await fetchUserOnce("user2"); // New fetch for different key
+ * ```
+ */
+export declare function onceAsyncKeyed<TArgs extends readonly unknown[], TReturn>(fn: (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
+/**
+ * Creates a resettable version of onceAsync that can be cleared and re-run.
+ *
+ * @param fn The async function to memoize
+ * @returns Object with execute and reset methods
+ *
+ * @example
+ * ```typescript
+ * const { execute: initialize, reset } = onceAsyncResettable(async () => {
+ *   await heavyInitialization();
+ * });
+ *
+ * await initialize(); // Runs
+ * await initialize(); // Cached
+ *
+ * reset(); // Clear cache
+ * await initialize(); // Runs again
+ * ```
+ */
+export declare function onceAsyncResettable<T>(fn: () => Promise<T>): {
+    execute: () => Promise<T>;
+    reset: () => void;
+};
+//# sourceMappingURL=async-utils.d.ts.map

package/dist/async-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-utils.d.ts","sourceRoot":"","sources":["../src/async-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,OAAO,CAAC,CAAC,CAAC,CAcnE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,EAAE,OAAO,EACvE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,OAAO,CAAC,GACtC,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,OAAO,CAAC,CAYtC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG;IAC7D,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;IAC1B,KAAK,EAAE,MAAM,IAAI,CAAC;CAClB,CAmBA"}

package/dist/async-utils.js

@@ -0,0 +1,108 @@
+/**
+ * Creates a function that ensures an async operation runs only once,
+ * returning the same promise for concurrent calls.
+ *
+ * Useful for initialization patterns where you want to ensure
+ * expensive async operations (like indexing, API calls, etc.)
+ * only happen once even if called multiple times.
+ *
+ * @param fn The async function to memoize
+ * @returns A function that returns the same promise on subsequent calls
+ *
+ * @example
+ * ```typescript
+ * const initializeOnce = onceAsync(async () => {
+ *   await heavyInitialization();
+ *   console.log("Initialized!");
+ * });
+ *
+ * // All these calls will share the same promise
+ * await initializeOnce();
+ * await initializeOnce(); // Won't run again
+ * await initializeOnce(); // Won't run again
+ * ```
+ */
+export function onceAsync(fn) {
+    let promise = null;
+    return () => {
+        if (!promise) {
+            try {
+                promise = fn();
+            }
+            catch (error) {
+                // Convert synchronous errors to rejected promises
+                promise = Promise.reject(error);
+            }
+        }
+        return promise;
+    };
+}
+/**
+ * Creates a function that ensures an async operation runs only once per key,
+ * useful for caching expensive operations with different parameters.
+ *
+ * @param fn The async function to memoize
+ * @returns A function that memoizes results by key
+ *
+ * @example
+ * ```typescript
+ * const fetchUserOnce = onceAsyncKeyed(async (userId: string) => {
+ *   return await api.getUser(userId);
+ * });
+ *
+ * // Each unique userId will only be fetched once
+ * await fetchUserOnce("user1");
+ * await fetchUserOnce("user1"); // Returns cached promise
+ * await fetchUserOnce("user2"); // New fetch for different key
+ * ```
+ */
+export function onceAsyncKeyed(fn) {
+    const cache = new Map();
+    return (...args) => {
+        const key = JSON.stringify(args);
+        if (!cache.has(key)) {
+            cache.set(key, fn(...args));
+        }
+        return cache.get(key);
+    };
+}
+/**
+ * Creates a resettable version of onceAsync that can be cleared and re-run.
+ *
+ * @param fn The async function to memoize
+ * @returns Object with execute and reset methods
+ *
+ * @example
+ * ```typescript
+ * const { execute: initialize, reset } = onceAsyncResettable(async () => {
+ *   await heavyInitialization();
+ * });
+ *
+ * await initialize(); // Runs
+ * await initialize(); // Cached
+ *
+ * reset(); // Clear cache
+ * await initialize(); // Runs again
+ * ```
+ */
+export function onceAsyncResettable(fn) {
+    let promise = null;
+    return {
+        execute: () => {
+            if (!promise) {
+                try {
+                    promise = fn();
+                }
+                catch (error) {
+                    // Convert synchronous errors to rejected promises
+                    promise = Promise.reject(error);
+                }
+            }
+            return promise;
+        },
+        reset: () => {
+            promise = null;
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/batch-operations.d.ts

@@ -0,0 +1,11 @@
+export interface BatchOperationOptions {
+    closeAfter?: boolean;
+    callOnComplete?: boolean;
+}
+export interface BatchOperationResult {
+    successCount: number;
+    errorCount: number;
+}
+export declare function runBatchOperation<T>(items: T[], operationLabel: string, handler: (item: T) => Promise<void>, showResult?: boolean): Promise<BatchOperationResult>;
+export declare function showBatchOperationResult(operation: string, successCount: number, errorCount: number): void;
+//# sourceMappingURL=batch-operations.d.ts.map

package/dist/batch-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-operations.d.ts","sourceRoot":"","sources":["../src/batch-operations.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,qBAAqB;IACrC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACpC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACnB;AAED,wBAAsB,iBAAiB,CAAC,CAAC,EACxC,KAAK,EAAE,CAAC,EAAE,EACV,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,EACnC,UAAU,GAAE,OAAc,GACxB,OAAO,CAAC,oBAAoB,CAAC,CAmB/B;AAED,wBAAgB,wBAAwB,CACvC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,GAChB,IAAI,CAUN"}

package/dist/batch-operations.js

@@ -0,0 +1,31 @@
+import { __awaiter } from "tslib";
+import { Notice } from "obsidian";
+export function runBatchOperation(items_1, operationLabel_1, handler_1) {
+    return __awaiter(this, arguments, void 0, function* (items, operationLabel, handler, showResult = true) {
+        let successCount = 0;
+        let errorCount = 0;
+        for (const item of items) {
+            try {
+                yield handler(item);
+                successCount++;
+            }
+            catch (error) {
+                console.error(`${operationLabel}: error processing item:`, error);
+                errorCount++;
+            }
+        }
+        if (showResult) {
+            showBatchOperationResult(operationLabel, successCount, errorCount);
+        }
+        return { successCount, errorCount };
+    });
+}
+export function showBatchOperationResult(operation, successCount, errorCount) {
+    if (errorCount === 0) {
+        new Notice(`${operation}: ${successCount} item${successCount === 1 ? "" : "s"} processed successfully`);
+    }
+    else {
+        new Notice(`${operation}: ${successCount} succeeded, ${errorCount} failed. Check console for details.`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/child-reference-utils.d.ts

@@ -0,0 +1,9 @@
+import { TFile } from "obsidian";
+export interface VaultAdapter {
+    getAbstractFileByPath(path: string): TFile | null;
+}
+export declare function extractDirectoryPath(filePath: string): string;
+export declare function isRelativeChildReference(childRef: string): boolean;
+export declare function normalizeChildReference(childRef: string, vault: VaultAdapter, currentFileDirectory?: string): string;
+export declare function normalizeChildReferences(childRefs: string[], vault: VaultAdapter, currentFileDirectory?: string): string[];
+//# sourceMappingURL=child-reference-utils.d.ts.map

package/dist/child-reference-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-reference-utils.d.ts","sourceRoot":"","sources":["../src/child-reference-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAIjC,MAAM,WAAW,YAAY;IAC5B,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,CAAC;CAClD;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAM7D;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAMlE;AAED,wBAAgB,uBAAuB,CACtC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,YAAY,EACnB,oBAAoB,CAAC,EAAE,MAAM,GAC3B,MAAM,CAqCR;AAED,wBAAgB,wBAAwB,CACvC,SAAS,EAAE,MAAM,EAAE,EACnB,KAAK,EAAE,YAAY,EACnB,oBAAoB,CAAC,EAAE,MAAM,GAC3B,MAAM,EAAE,CAIV"}

package/dist/child-reference-utils.js

@@ -0,0 +1,57 @@
+import { TFile } from "obsidian";
+import { createFileLink } from "./file-operations";
+import { extractFilePathFromLink } from "./link-parser";
+export function extractDirectoryPath(filePath) {
+    const lastSlashIndex = filePath.lastIndexOf("/");
+    if (lastSlashIndex === -1) {
+        return "";
+    }
+    return filePath.substring(0, lastSlashIndex);
+}
+export function isRelativeChildReference(childRef) {
+    const filePath = extractFilePathFromLink(childRef);
+    if (!filePath) {
+        return !childRef.includes("/");
+    }
+    return !filePath.includes("/");
+}
+export function normalizeChildReference(childRef, vault, currentFileDirectory) {
+    const filePath = extractFilePathFromLink(childRef);
+    // Handle plain text references (not wrapped in [[]])
+    if (!filePath) {
+        // If it's not a link format, check if it should be converted to a link
+        if (!childRef.includes("/") && currentFileDirectory !== undefined) {
+            // This is a plain text reference that might need to be converted to a link
+            const potentialPath = currentFileDirectory
+                ? `${currentFileDirectory}/${childRef.endsWith(".md") ? childRef : `${childRef}.md`}`
+                : childRef.endsWith(".md")
+                    ? childRef
+                    : `${childRef}.md`;
+            const file = vault.getAbstractFileByPath(potentialPath);
+            if (file instanceof TFile) {
+                return createFileLink(file);
+            }
+        }
+        return childRef;
+    }
+    // Handle relative references by making them absolute
+    if (isRelativeChildReference(childRef) && currentFileDirectory) {
+        const absolutePath = `${currentFileDirectory}/${filePath}`;
+        const file = vault.getAbstractFileByPath(absolutePath);
+        if (file instanceof TFile) {
+            return createFileLink(file);
+        }
+    }
+    // For absolute references or when no directory context, try to find the file as-is
+    const file = vault.getAbstractFileByPath(filePath);
+    if (file instanceof TFile) {
+        return createFileLink(file);
+    }
+    return childRef;
+}
+export function normalizeChildReferences(childRefs, vault, currentFileDirectory) {
+    return childRefs.map((childRef) => {
+        return normalizeChildReference(childRef, vault, currentFileDirectory);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/date-recurrence-utils.d.ts

@@ -0,0 +1,32 @@
+import type { DateTime } from "luxon";
+export type RecurrenceType = "daily" | "weekly" | "bi-weekly" | "monthly" | "bi-monthly" | "yearly";
+export type Weekday = "sunday" | "monday" | "tuesday" | "wednesday" | "thursday" | "friday" | "saturday";
+export declare const WEEKDAY_TO_NUMBER: Record<Weekday, number>;
+/**
+ * Calculates the next occurrence date based on recurrence type and optional weekdays
+ */
+export declare function getNextOccurrence(currentDate: DateTime, recurrenceType: RecurrenceType, weekdays?: Weekday[]): DateTime;
+/**
+ * Checks if a given date matches any of the specified weekdays
+ */
+export declare function isDateOnWeekdays(date: DateTime, weekdays: Weekday[]): boolean;
+/**
+ * Finds the next occurrence on specified weekdays
+ */
+export declare function getNextWeekdayOccurrence(currentDate: DateTime, weekdays: Weekday[]): DateTime;
+/**
+ * Finds the next bi-weekly occurrence on specified weekdays
+ */
+export declare function getNextBiWeeklyOccurrence(currentDate: DateTime, weekdays: Weekday[]): DateTime;
+/**
+ * Iterates through all occurrence dates in a given range based on recurrence rules
+ */
+export declare function iterateOccurrencesInRange(startDate: DateTime, rrules: {
+    type: RecurrenceType;
+    weekdays?: Weekday[];
+}, rangeStart: DateTime, rangeEnd: DateTime): Generator<DateTime, void, unknown>;
+/**
+ * Calculates a DateTime for a specific date with optional time
+ */
+export declare function calculateInstanceDateTime(instanceDate: DateTime, timeString?: string): DateTime;
+//# sourceMappingURL=date-recurrence-utils.d.ts.map

package/dist/date-recurrence-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-recurrence-utils.d.ts","sourceRoot":"","sources":["../src/date-recurrence-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEtC,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,SAAS,GAAG,YAAY,GAAG,QAAQ,CAAC;AAEpG,MAAM,MAAM,OAAO,GAChB,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,WAAW,GACX,UAAU,GACV,QAAQ,GACR,UAAU,CAAC;AAEd,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAQrD,CAAC;AAEF;;GAEG;AACH,wBAAgB,iBAAiB,CAChC,WAAW,EAAE,QAAQ,EACrB,cAAc,EAAE,cAAc,EAC9B,QAAQ,CAAC,EAAE,OAAO,EAAE,GAClB,QAAQ,CAuBV;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,CAQ7E;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,QAAQ,CAgB7F;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,QAAQ,CAI9F;AAED;;GAEG;AACH,wBAAiB,yBAAyB,CACzC,SAAS,EAAE,QAAQ,EACnB,MAAM,EAAE;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAA;CAAE,EACtD,UAAU,EAAE,QAAQ,EACpB,QAAQ,EAAE,QAAQ,GAChB,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,CAgCpC;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,QAAQ,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,QAAQ,CAO/F"}

package/dist/date-recurrence-utils.js

@@ -0,0 +1,117 @@
+export const WEEKDAY_TO_NUMBER = {
+    sunday: 0,
+    monday: 1,
+    tuesday: 2,
+    wednesday: 3,
+    thursday: 4,
+    friday: 5,
+    saturday: 6,
+};
+/**
+ * Calculates the next occurrence date based on recurrence type and optional weekdays
+ */
+export function getNextOccurrence(currentDate, recurrenceType, weekdays) {
+    switch (recurrenceType) {
+        case "daily":
+            return currentDate.plus({ days: 1 });
+        case "weekly":
+            if (weekdays && weekdays.length > 0) {
+                return getNextWeekdayOccurrence(currentDate, weekdays);
+            }
+            return currentDate.plus({ weeks: 1 });
+        case "bi-weekly":
+            if (weekdays && weekdays.length > 0) {
+                return getNextBiWeeklyOccurrence(currentDate, weekdays);
+            }
+            return currentDate.plus({ weeks: 2 });
+        case "monthly":
+            return currentDate.plus({ months: 1 });
+        case "bi-monthly":
+            return currentDate.plus({ months: 2 });
+        case "yearly":
+            return currentDate.plus({ years: 1 });
+        default:
+            return currentDate.plus({ days: 1 });
+    }
+}
+/**
+ * Checks if a given date matches any of the specified weekdays
+ */
+export function isDateOnWeekdays(date, weekdays) {
+    const dateWeekday = date.weekday;
+    const luxonWeekdays = weekdays.map((day) => {
+        const dayNumber = WEEKDAY_TO_NUMBER[day];
+        return dayNumber === 0 ? 7 : dayNumber; // Convert Sunday from 0 to 7 for Luxon
+    });
+    return luxonWeekdays.includes(dateWeekday);
+}
+/**
+ * Finds the next occurrence on specified weekdays
+ */
+export function getNextWeekdayOccurrence(currentDate, weekdays) {
+    const currentWeekday = currentDate.weekday;
+    const luxonWeekdays = weekdays.map((day) => {
+        const dayNumber = WEEKDAY_TO_NUMBER[day];
+        return dayNumber === 0 ? 7 : dayNumber; // Convert Sunday from 0 to 7 for Luxon
+    });
+    // Find next weekday in the current week (after today)
+    const nextWeekday = luxonWeekdays.find((day) => day > currentWeekday);
+    if (nextWeekday) {
+        return currentDate.set({ weekday: nextWeekday });
+    }
+    // No more weekdays this week, go to first weekday of next week
+    const firstWeekday = Math.min(...luxonWeekdays);
+    return currentDate.plus({ weeks: 1 }).set({ weekday: firstWeekday });
+}
+/**
+ * Finds the next bi-weekly occurrence on specified weekdays
+ */
+export function getNextBiWeeklyOccurrence(currentDate, weekdays) {
+    const nextWeekly = getNextWeekdayOccurrence(currentDate, weekdays);
+    // Add one more week to make it bi-weekly
+    return nextWeekly.plus({ weeks: 1 });
+}
+/**
+ * Iterates through all occurrence dates in a given range based on recurrence rules
+ */
+export function* iterateOccurrencesInRange(startDate, rrules, rangeStart, rangeEnd) {
+    let currentDate = startDate > rangeStart ? startDate : rangeStart;
+    while (currentDate <= rangeEnd) {
+        // Check if current date should have an event
+        let shouldAddEvent = false;
+        if (rrules.type === "daily") {
+            shouldAddEvent = true;
+        }
+        else if (rrules.type === "weekly" || rrules.type === "bi-weekly") {
+            if (rrules.weekdays && rrules.weekdays.length > 0) {
+                shouldAddEvent = isDateOnWeekdays(currentDate, rrules.weekdays);
+            }
+            else {
+                shouldAddEvent = true;
+            }
+        }
+        else {
+            shouldAddEvent = true;
+        }
+        if (shouldAddEvent) {
+            yield currentDate;
+        }
+        // Calculate next occurrence
+        const nextDate = getNextOccurrence(currentDate, rrules.type, rrules.weekdays);
+        if (nextDate > rangeEnd) {
+            break;
+        }
+        currentDate = nextDate;
+    }
+}
+/**
+ * Calculates a DateTime for a specific date with optional time
+ */
+export function calculateInstanceDateTime(instanceDate, timeString) {
+    if (!timeString) {
+        return instanceDate.startOf("day");
+    }
+    const [hours, minutes] = timeString.split(":").map(Number);
+    return instanceDate.set({ hour: hours, minute: minutes, second: 0, millisecond: 0 });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-recurrence-utils.js","sourceRoot":"","sources":["../src/date-recurrence-utils.ts"],"names":[],"mappings":"AAaA,MAAM,CAAC,MAAM,iBAAiB,GAA4B;IACzD,MAAM,EAAE,CAAC;IACT,MAAM,EAAE,CAAC;IACT,OAAO,EAAE,CAAC;IACV,SAAS,EAAE,CAAC;IACZ,QAAQ,EAAE,CAAC;IACX,MAAM,EAAE,CAAC;IACT,QAAQ,EAAE,CAAC;CACX,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAChC,WAAqB,EACrB,cAA8B,EAC9B,QAAoB;IAEpB,QAAQ,cAAc,EAAE,CAAC;QACxB,KAAK,OAAO;YACX,OAAO,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;QACtC,KAAK,QAAQ;YACZ,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACrC,OAAO,wBAAwB,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;YACxD,CAAC;YACD,OAAO,WAAW,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;QACvC,KAAK,WAAW;YACf,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACrC,OAAO,yBAAyB,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;YACzD,CAAC;YACD,OAAO,WAAW,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;QACvC,KAAK,SAAS;YACb,OAAO,WAAW,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;QACxC,KAAK,YAAY;YAChB,OAAO,WAAW,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;QACxC,KAAK,QAAQ;YACZ,OAAO,WAAW,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;QACvC;YACC,OAAO,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;IACvC,CAAC;AACF,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAc,EAAE,QAAmB;IACnE,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC;IACjC,MAAM,aAAa,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;QAC1C,MAAM,SAAS,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC;QACzC,OAAO,SAAS,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,uCAAuC;IAChF,CAAC,CAAC,CAAC;IAEH,OAAO,aAAa,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AAC5C,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,wBAAwB,CAAC,WAAqB,EAAE,QAAmB;IAClF,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,CAAC;IAC3C,MAAM,aAAa,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;QAC1C,MAAM,SAAS,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC;QACzC,OAAO,SAAS,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,uCAAuC;IAChF,CAAC,CAAC,CAAC;IAEH,sDAAsD;IACtD,MAAM,WAAW,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,GAAG,cAAc,CAAC,CAAC;IACtE,IAAI,WAAW,EAAE,CAAC;QACjB,OAAO,WAAW,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,WAAwC,EAAE,CAAC,CAAC;IAC/E,CAAC;IAED,+DAA+D;IAC/D,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,CAAC;IAChD,OAAO,WAAW,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,YAAyC,EAAE,CAAC,CAAC;AACnG,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,yBAAyB,CAAC,WAAqB,EAAE,QAAmB;IACnF,MAAM,UAAU,GAAG,wBAAwB,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;IACnE,yCAAyC;IACzC,OAAO,UAAU,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;AACtC,CAAC;AAED;;GAEG;AACH,MAAM,SAAS,CAAC,CAAC,yBAAyB,CACzC,SAAmB,EACnB,MAAsD,EACtD,UAAoB,EACpB,QAAkB;IAElB,IAAI,WAAW,GAAG,SAAS,GAAG,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC;IAElE,OAAO,WAAW,IAAI,QAAQ,EAAE,CAAC;QAChC,6CAA6C;QAC7C,IAAI,cAAc,GAAG,KAAK,CAAC;QAE3B,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC7B,cAAc,GAAG,IAAI,CAAC;QACvB,CAAC;aAAM,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YACpE,IAAI,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACnD,cAAc,GAAG,gBAAgB,CAAC,WAAW,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;YACjE,CAAC;iBAAM,CAAC;gBACP,cAAc,GAAG,IAAI,CAAC;YACvB,CAAC;QACF,CAAC;aAAM,CAAC;YACP,cAAc,GAAG,IAAI,CAAC;QACvB,CAAC;QAED,IAAI,cAAc,EAAE,CAAC;YACpB,MAAM,WAAW,CAAC;QACnB,CAAC;QAED,4BAA4B;QAC5B,MAAM,QAAQ,GAAG,iBAAiB,CAAC,WAAW,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;QAE9E,IAAI,QAAQ,GAAG,QAAQ,EAAE,CAAC;YACzB,MAAM;QACP,CAAC;QAED,WAAW,GAAG,QAAQ,CAAC;IACxB,CAAC;AACF,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,yBAAyB,CAAC,YAAsB,EAAE,UAAmB;IACpF,IAAI,CAAC,UAAU,EAAE,CAAC;QACjB,OAAO,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;IAED,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3D,OAAO,YAAY,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC;AACtF,CAAC","sourcesContent":["import type { DateTime } from \"luxon\";\n\nexport type RecurrenceType = \"daily\" | \"weekly\" | \"bi-weekly\" | \"monthly\" | \"bi-monthly\" | \"yearly\";\n\nexport type Weekday =\n\t| \"sunday\"\n\t| \"monday\"\n\t| \"tuesday\"\n\t| \"wednesday\"\n\t| \"thursday\"\n\t| \"friday\"\n\t| \"saturday\";\n\nexport const WEEKDAY_TO_NUMBER: Record<Weekday, number> = {\n\tsunday: 0,\n\tmonday: 1,\n\ttuesday: 2,\n\twednesday: 3,\n\tthursday: 4,\n\tfriday: 5,\n\tsaturday: 6,\n};\n\n/**\n * Calculates the next occurrence date based on recurrence type and optional weekdays\n */\nexport function getNextOccurrence(\n\tcurrentDate: DateTime,\n\trecurrenceType: RecurrenceType,\n\tweekdays?: Weekday[]\n): DateTime {\n\tswitch (recurrenceType) {\n\t\tcase \"daily\":\n\t\t\treturn currentDate.plus({ days: 1 });\n\t\tcase \"weekly\":\n\t\t\tif (weekdays && weekdays.length > 0) {\n\t\t\t\treturn getNextWeekdayOccurrence(currentDate, weekdays);\n\t\t\t}\n\t\t\treturn currentDate.plus({ weeks: 1 });\n\t\tcase \"bi-weekly\":\n\t\t\tif (weekdays && weekdays.length > 0) {\n\t\t\t\treturn getNextBiWeeklyOccurrence(currentDate, weekdays);\n\t\t\t}\n\t\t\treturn currentDate.plus({ weeks: 2 });\n\t\tcase \"monthly\":\n\t\t\treturn currentDate.plus({ months: 1 });\n\t\tcase \"bi-monthly\":\n\t\t\treturn currentDate.plus({ months: 2 });\n\t\tcase \"yearly\":\n\t\t\treturn currentDate.plus({ years: 1 });\n\t\tdefault:\n\t\t\treturn currentDate.plus({ days: 1 });\n\t}\n}\n\n/**\n * Checks if a given date matches any of the specified weekdays\n */\nexport function isDateOnWeekdays(date: DateTime, weekdays: Weekday[]): boolean {\n\tconst dateWeekday = date.weekday;\n\tconst luxonWeekdays = weekdays.map((day) => {\n\t\tconst dayNumber = WEEKDAY_TO_NUMBER[day];\n\t\treturn dayNumber === 0 ? 7 : dayNumber; // Convert Sunday from 0 to 7 for Luxon\n\t});\n\n\treturn luxonWeekdays.includes(dateWeekday);\n}\n\n/**\n * Finds the next occurrence on specified weekdays\n */\nexport function getNextWeekdayOccurrence(currentDate: DateTime, weekdays: Weekday[]): DateTime {\n\tconst currentWeekday = currentDate.weekday;\n\tconst luxonWeekdays = weekdays.map((day) => {\n\t\tconst dayNumber = WEEKDAY_TO_NUMBER[day];\n\t\treturn dayNumber === 0 ? 7 : dayNumber; // Convert Sunday from 0 to 7 for Luxon\n\t});\n\n\t// Find next weekday in the current week (after today)\n\tconst nextWeekday = luxonWeekdays.find((day) => day > currentWeekday);\n\tif (nextWeekday) {\n\t\treturn currentDate.set({ weekday: nextWeekday as 1 | 2 | 3 | 4 | 5 | 6 | 7 });\n\t}\n\n\t// No more weekdays this week, go to first weekday of next week\n\tconst firstWeekday = Math.min(...luxonWeekdays);\n\treturn currentDate.plus({ weeks: 1 }).set({ weekday: firstWeekday as 1 | 2 | 3 | 4 | 5 | 6 | 7 });\n}\n\n/**\n * Finds the next bi-weekly occurrence on specified weekdays\n */\nexport function getNextBiWeeklyOccurrence(currentDate: DateTime, weekdays: Weekday[]): DateTime {\n\tconst nextWeekly = getNextWeekdayOccurrence(currentDate, weekdays);\n\t// Add one more week to make it bi-weekly\n\treturn nextWeekly.plus({ weeks: 1 });\n}\n\n/**\n * Iterates through all occurrence dates in a given range based on recurrence rules\n */\nexport function* iterateOccurrencesInRange(\n\tstartDate: DateTime,\n\trrules: { type: RecurrenceType; weekdays?: Weekday[] },\n\trangeStart: DateTime,\n\trangeEnd: DateTime\n): Generator<DateTime, void, unknown> {\n\tlet currentDate = startDate > rangeStart ? startDate : rangeStart;\n\n\twhile (currentDate <= rangeEnd) {\n\t\t// Check if current date should have an event\n\t\tlet shouldAddEvent = false;\n\n\t\tif (rrules.type === \"daily\") {\n\t\t\tshouldAddEvent = true;\n\t\t} else if (rrules.type === \"weekly\" || rrules.type === \"bi-weekly\") {\n\t\t\tif (rrules.weekdays && rrules.weekdays.length > 0) {\n\t\t\t\tshouldAddEvent = isDateOnWeekdays(currentDate, rrules.weekdays);\n\t\t\t} else {\n\t\t\t\tshouldAddEvent = true;\n\t\t\t}\n\t\t} else {\n\t\t\tshouldAddEvent = true;\n\t\t}\n\n\t\tif (shouldAddEvent) {\n\t\t\tyield currentDate;\n\t\t}\n\n\t\t// Calculate next occurrence\n\t\tconst nextDate = getNextOccurrence(currentDate, rrules.type, rrules.weekdays);\n\n\t\tif (nextDate > rangeEnd) {\n\t\t\tbreak;\n\t\t}\n\n\t\tcurrentDate = nextDate;\n\t}\n}\n\n/**\n * Calculates a DateTime for a specific date with optional time\n */\nexport function calculateInstanceDateTime(instanceDate: DateTime, timeString?: string): DateTime {\n\tif (!timeString) {\n\t\treturn instanceDate.startOf(\"day\");\n\t}\n\n\tconst [hours, minutes] = timeString.split(\":\").map(Number);\n\treturn instanceDate.set({ hour: hours, minute: minutes, second: 0, millisecond: 0 });\n}\n"]}

package/dist/date-utils.d.ts

@@ -0,0 +1,20 @@
+export declare const formatDateTimeForInput: (dateString: string) => string;
+export declare const formatDateForInput: (dateString: string) => string;
+/**
+ * Converts input value to ISO string, handling edge cases where
+ * browser datetime-local inputs behave differently across platforms.
+ * Returns null for invalid dates to prevent silent failures.
+ */
+export declare const inputValueToISOString: (inputValue: string) => string | null;
+export declare const formatDuration: (minutes: number) => string;
+/**
+ * Parse time string from datetime value - extracts HH:mm format
+ * Rejects plain HH:mm format, requires full datetime
+ */
+export declare const parseTimeString: (value: string | null) => string | undefined;
+/**
+ * Parse and validate datetime strings for event parsing
+ * Supports multiple formats including date-only and datetime formats
+ */
+export declare const parseDateTimeString: (value: string | null) => string | undefined;
+//# sourceMappingURL=date-utils.d.ts.map

package/dist/date-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-utils.d.ts","sourceRoot":"","sources":["../src/date-utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB,GAAI,YAAY,MAAM,KAAG,MAgB3D,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,YAAY,MAAM,KAAG,MAavD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAAI,YAAY,MAAM,KAAG,MAAM,GAAG,IAMnE,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,KAAG,MAIhD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,GAAG,IAAI,KAAG,MAAM,GAAG,SAgB/D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,MAAM,GAAG,IAAI,KAAG,MAAM,GAAG,SA8BnE,CAAC"}