@livenetworks/ashlar 2.0.6 → 2.0.8

package/components/ln-data-store/src/data-store-model.js

@@ -1,155 +1,184 @@
-import { compareValues, detectValueType } from '../../ln-core/compare.js';
-import { matchesFilterValues, matchesSearchTokens, tokenizeSearchQuery } from '../../ln-core/matching.js';
-
-/**
- * Sorts an array of record objects by field and direction using pure core comparison.
- * @param {Array<Record<string, any>>} records
- * @param {{ field?: string, direction?: string } | null} [sort]
- * @param {Intl.Collator} [collator]
- * @returns {Array<Record<string, any>>}
- */
-export function sortRecords(records, sort, collator) {
-	if (!Array.isArray(records) || !sort || !sort.field) return records;
-	const { field, direction } = sort;
-	const desc = direction === 'desc';
-
-	// Lock the value type once for the entire sort operation (per Doctrinal / compare.js rules)
-	const sampleValues = records.map(r => (r ? r[field] : undefined));
-	const valueType = detectValueType(sampleValues);
-
-	return [...records].sort((a, b) => {
-		const va = a ? a[field] : undefined;
-		const vb = b ? b[field] : undefined;
-
-		const result = compareValues(va, vb, valueType, collator);
-		return desc ? -result : result;
-	});
-}
-
-/**
- * Filters an array of records against a dictionary of active filter arrays.
- * Reuses matchesFilterValues from ln-core/matching (AND across fields, OR within field).
- * @param {Array<Record<string, any>>} records
- * @param {Record<string, Array<any>>} filters
- * @returns {Array<Record<string, any>>}
- */
-export function filterRecords(records, filters) {
-	if (!Array.isArray(records) || !filters || typeof filters !== 'object') return records;
-
-	const keys = Object.keys(filters).filter(k => Array.isArray(filters[k]) && filters[k].length > 0);
-	if (!keys.length) return records;
-
-	return records.filter(record => {
-		if (!record) return false;
-		return keys.every(field => matchesFilterValues(record[field], filters[field]));
-	});
-}
-
-/**
- * Searches records across specified fields using ln-core/matching tokenization and matching.
- * @param {Array<Record<string, any>>} records
- * @param {string} query
- * @param {string[]} searchFields
- * @returns {Array<Record<string, any>>}
- */
-export function searchRecords(records, query, searchFields) {
-	if (!Array.isArray(records) || !query || !searchFields || !searchFields.length) return records;
-
-	const tokens = tokenizeSearchQuery(query);
-	if (!tokens.length) return records;
-
-	return records.filter(record => {
-		if (!record) return false;
-		return tokens.every(token =>
-			searchFields.some(field => {
-				const val = record[field];
-				return val != null && matchesSearchTokens(String(val), [token]);
-			})
-		);
-	});
-}
-
-/**
- * Computes aggregates (count, sum, avg) on a specific field across records.
- * @param {Array<Record<string, any>>} records
- * @param {string} field
- * @param {'count' | 'sum' | 'avg'} fn
- * @returns {number}
- */
-export function aggregateRecords(records, field, fn) {
-	if (!Array.isArray(records) || !records.length) return 0;
-	if (fn === 'count') return records.length;
-
-	const numbers = records
-		.map(r => (r && r[field] != null ? parseFloat(r[field]) : NaN))
-		.filter(v => Number.isFinite(v));
-
-	const sum = numbers.reduce((a, b) => a + b, 0);
-
-	if (fn === 'sum') return sum;
-	if (fn === 'avg') return numbers.length ? sum / numbers.length : 0;
-	return 0;
-}
-
-/**
- * Executes full in-memory query evaluation: filter -> search -> sort -> slice.
- * @param {Array<Record<string, any>>} records
- * @param {{ filters?: Record<string, any[]>, search?: string, sort?: { field?: string, direction?: string }, offset?: number, limit?: number }} [options={}]
- * @param {string[]} [searchFields=[]]
- * @param {Intl.Collator} [collator]
- * @returns {{ records: Array<Record<string, any>>, total: number, filtered: number }}
- */
-export function queryRecords(records, options = {}, searchFields = [], collator) {
-	if (!Array.isArray(records)) {
-		return { records: [], total: 0, filtered: 0 };
-	}
-
-	const total = records.length;
-	let result = records;
-
-	if (options.filters) {
-		result = filterRecords(result, options.filters);
-	}
-	if (options.search) {
-		result = searchRecords(result, options.search, searchFields);
-	}
-
-	const filtered = result.length;
-
-	if (options.sort) {
-		result = sortRecords(result, options.sort, collator);
-	}
-
-	if (options.offset || options.limit) {
-		const offset = options.offset || 0;
-		const limit = options.limit || result.length;
-		result = result.slice(offset, offset + limit);
-	}
-
-	return { records: result, total, filtered };
-}
-
-/**
- * Decorates records with computed fields (pure, no console side-effects).
- * @param {Array<Record<string, any>>} records
- * @param {Record<string, (record: any) => any>} [computed]
- * @returns {Array<Record<string, any>>}
- */
-export function decorateRecords(records, computed) {
-	if (!Array.isArray(records) || !computed || typeof computed !== 'object') return records;
-
-	return records.map(record => {
-		if (!record) return null;
-		const copy = { ...record };
-		for (const [fieldName, fn] of Object.entries(computed)) {
-			if (typeof fn === 'function') {
-				try {
-					copy[fieldName] = fn(record);
-				} catch (_) {
-					copy[fieldName] = undefined;
-				}
-			}
-		}
-		return copy;
-	});
-}
+import { compareValues, detectValueType } from '../../ln-core/compare.js';
+import { matchesFilterValues, matchesSearchTokens, tokenizeSearchQuery } from '../../ln-core/matching.js';
+
+/**
+ * Sorts an array of record objects by field and direction using pure core comparison.
+ * @param {Array<Record<string, any>>} records
+ * @param {{ field?: string, direction?: string } | null} [sort]
+ * @param {Intl.Collator} [collator]
+ * @returns {Array<Record<string, any>>}
+ */
+export function sortRecords(records, sort, collator) {
+	if (!Array.isArray(records) || !sort || !sort.field) return records;
+	const { field, direction } = sort;
+	const desc = direction === 'desc';
+
+	// Lock the value type once for the entire sort operation (per Doctrinal / compare.js rules)
+	const sampleValues = records.map(r => (r ? r[field] : undefined));
+	const valueType = detectValueType(sampleValues);
+
+	return [...records].sort((a, b) => {
+		const va = a ? a[field] : undefined;
+		const vb = b ? b[field] : undefined;
+
+		const result = compareValues(va, vb, valueType, collator);
+		return desc ? -result : result;
+	});
+}
+
+/**
+ * Filters an array of records against a dictionary of active filter arrays.
+ * Reuses matchesFilterValues from ln-core/matching (AND across fields, OR within field).
+ * @param {Array<Record<string, any>>} records
+ * @param {Record<string, Array<any>>} filters
+ * @returns {Array<Record<string, any>>}
+ */
+export function filterRecords(records, filters) {
+	if (!Array.isArray(records) || !filters || typeof filters !== 'object') return records;
+
+	const keys = Object.keys(filters).filter(k => Array.isArray(filters[k]) && filters[k].length > 0);
+	if (!keys.length) return records;
+
+	return records.filter(record => {
+		if (!record) return false;
+		return keys.every(field => matchesFilterValues(record[field], filters[field]));
+	});
+}
+
+/**
+ * Searches records across specified fields using ln-core/matching tokenization and matching.
+ * @param {Array<Record<string, any>>} records
+ * @param {string} query
+ * @param {string[]} searchFields
+ * @returns {Array<Record<string, any>>}
+ */
+export function searchRecords(records, query, searchFields) {
+	if (!Array.isArray(records) || !query || !searchFields || !searchFields.length) return records;
+
+	const tokens = tokenizeSearchQuery(query);
+	if (!tokens.length) return records;
+
+	return records.filter(record => {
+		if (!record) return false;
+		return tokens.every(token =>
+			searchFields.some(field => {
+				const val = record[field];
+				return val != null && matchesSearchTokens(String(val), [token]);
+			})
+		);
+	});
+}
+
+/**
+ * Computes aggregates (count, sum, avg) on a specific field across records.
+ * @param {Array<Record<string, any>>} records
+ * @param {string} field
+ * @param {'count' | 'sum' | 'avg'} fn
+ * @returns {number}
+ */
+export function aggregateRecords(records, field, fn) {
+	if (!Array.isArray(records) || !records.length) return 0;
+	if (fn === 'count') return records.length;
+
+	const numbers = records
+		.map(r => (r && r[field] != null ? parseFloat(r[field]) : NaN))
+		.filter(v => Number.isFinite(v));
+
+	const sum = numbers.reduce((a, b) => a + b, 0);
+
+	if (fn === 'sum') return sum;
+	if (fn === 'avg') return numbers.length ? sum / numbers.length : 0;
+	return 0;
+}
+
+/**
+ * Executes full in-memory query evaluation: filter -> search -> sort -> slice.
+ * @param {Array<Record<string, any>>} records
+ * @param {{ filters?: Record<string, any[]>, search?: string, sort?: { field?: string, direction?: string }, offset?: number, limit?: number }} [options={}]
+ * @param {string[]} [searchFields=[]]
+ * @param {Intl.Collator} [collator]
+ * @returns {{ records: Array<Record<string, any>>, total: number, filtered: number }}
+ */
+export function queryRecords(records, options = {}, searchFields = [], collator) {
+	if (!Array.isArray(records)) {
+		return { records: [], total: 0, filtered: 0 };
+	}
+
+	const total = records.length;
+	let result = records;
+
+	if (options.filters) {
+		result = filterRecords(result, options.filters);
+	}
+	if (options.search) {
+		result = searchRecords(result, options.search, searchFields);
+	}
+
+	const filtered = result.length;
+
+	if (options.sort) {
+		result = sortRecords(result, options.sort, collator);
+	}
+
+	if (options.offset || options.limit) {
+		const offset = options.offset || 0;
+		const limit = options.limit || result.length;
+		result = result.slice(offset, offset + limit);
+	}
+
+	return { records: result, total, filtered };
+}
+
+/**
+ * Decorates records with computed fields (pure, no console side-effects).
+ * @param {Array<Record<string, any>>} records
+ * @param {Record<string, (record: any) => any>} [computed]
+ * @returns {Array<Record<string, any>>}
+ */
+export function decorateRecords(records, computed) {
+	if (!Array.isArray(records) || !computed || typeof computed !== 'object') return records;
+
+	return records.map(record => {
+		if (!record) return null;
+		const copy = { ...record };
+		for (const [fieldName, fn] of Object.entries(computed)) {
+			if (typeof fn === 'function') {
+				try {
+					copy[fieldName] = fn(record);
+				} catch (_) {
+					copy[fieldName] = undefined;
+				}
+			}
+		}
+		return copy;
+	});
+}
+
+/**
+ * Pure helper to compute whether an IndexedDB upgrade is needed.
+ * @param {string[]} existingStoreNames
+ * @param {Record<string, { indexes: string[] }>} requiredStores
+ * @param {Record<string, string[]>} existingIndexMap
+ * @param {string} [metaStoreName='_meta']
+ * @returns {boolean}
+ */
+export function checkNeedsUpgrade(existingStoreNames, requiredStores, existingIndexMap, metaStoreName = '_meta') {
+	if (!Array.isArray(existingStoreNames) || !existingStoreNames.includes(metaStoreName)) return true;
+	for (const name of Object.keys(requiredStores || {})) {
+		if (!existingStoreNames.includes(name)) return true;
+		const requiredIdxs = (requiredStores[name] && requiredStores[name].indexes) || [];
+		const existingIdxs = (existingIndexMap && existingIndexMap[name]) || [];
+		if (requiredIdxs.some(idx => !existingIdxs.includes(idx))) return true;
+	}
+	return false;
+}
+
+/**
+ * Pure helper to normalize synchronization errors into a standard response shape.
+ * @param {any} err
+ * @returns {{ ok: false, error: string }}
+ */
+export function normalizeSyncError(err) {
+	const errorMsg = (err && err.message) ? err.message : String(err);
+	return { ok: false, error: errorMsg };
+}

package/components/ln-data-store/src/ln-data-store.js

@@ -1,6 +1,6 @@
 import { registerComponent, dispatch, setCryptoKey, getCryptoKey, encryptData, decryptData, defineAttrs, attrSpec, attrInt, attrBool, attrList } from '../../ln-core';
 import { createWindowIndex } from './window-index.js';
-import { aggregateRecords, decorateRecords, filterRecords, queryRecords } from './data-store-model.js';
+import { aggregateRecords, decorateRecords, filterRecords, queryRecords, checkNeedsUpgrade, normalizeSyncError } from './data-store-model.js';
 
 (function () {
 	const DOM_SELECTOR = 'data-ln-data-store';
@@ -66,7 +66,7 @@ import { aggregateRecords, decorateRecords, filterRecords, queryRecords } from '
 
 		_dbReady = new Promise(resolve => {
 			if (typeof indexedDB === 'undefined') {
-				console.warn('[ln-data-store] IndexedDB not available — falling back to in-memory store');
+				console.warn('[ln-data-store] IndexedDB is not available in this environment');
 				return resolve(null);
 			}
 
@@ -75,14 +75,24 @@ import { aggregateRecords, decorateRecords, filterRecords, queryRecords } from '
 			const probe = indexedDB.open(DB_NAME);
 
 			probe.onerror = () => {
-				console.warn('[ln-data-store] IndexedDB open failed — falling back to in-memory store');
+				console.warn('[ln-data-store] IndexedDB open failed');
 				resolve(null);
 			};
 
 			probe.onsuccess = e => {
 				const db = e.target.result;
 				const existing = Array.from(db.objectStoreNames);
-				const needsUpgrade = !existing.includes(META_STORE) || requiredNames.some(name => !existing.includes(name));
+				const existingRequired = requiredNames.filter(name => existing.includes(name));
+
+				let existingIndexMap = {};
+				if (existingRequired.length > 0) {
+					const tx = db.transaction(existingRequired, 'readonly');
+					for (const name of existingRequired) {
+						existingIndexMap[name] = Array.from(tx.objectStore(name).indexNames);
+					}
+				}
+
+				const needsUpgrade = checkNeedsUpgrade(existing, required, existingIndexMap, META_STORE);
 
 				if (!needsUpgrade) {
 					_setupVersionChangeHandler(db);
@@ -94,18 +104,35 @@ import { aggregateRecords, decorateRecords, filterRecords, queryRecords } from '
 				db.close();
 
 				const upgrade = indexedDB.open(DB_NAME, currentVersion + 1);
+				let settled = false;
+				let blockedTimeout = null;
 
 				upgrade.onblocked = () => {
 					console.warn('[ln-data-store] Database upgrade blocked — waiting for other tabs to close connection');
+					dispatch(document, 'ln-data-store:blocked', { db: DB_NAME });
+					if (!blockedTimeout) {
+						blockedTimeout = setTimeout(() => {
+							if (settled) return;
+							console.warn('[ln-data-store] Database upgrade timed out while blocked');
+							settled = true;
+							_dbReady = null;
+							resolve(null);
+						}, 5000);
+					}
 				};
 
 				upgrade.onerror = () => {
+					if (settled) return;
+					if (blockedTimeout) clearTimeout(blockedTimeout);
+					settled = true;
+					_dbReady = null;
 					console.warn('[ln-data-store] Database upgrade failed');
 					resolve(null);
 				};
 
 				upgrade.onupgradeneeded = e => {
 					const db = e.target.result;
+					const tx = e.target.transaction;
 					if (!db.objectStoreNames.contains(META_STORE)) {
 						db.createObjectStore(META_STORE, { keyPath: 'key' });
 					}
@@ -115,11 +142,24 @@ import { aggregateRecords, decorateRecords, filterRecords, queryRecords } from '
 							for (const idx of required[storeName].indexes) {
 								store.createIndex(idx, idx, { unique: false });
 							}
+						} else {
+							const store = tx.objectStore(storeName);
+							for (const idx of required[storeName].indexes) {
+								if (!store.indexNames.contains(idx)) {
+									store.createIndex(idx, idx, { unique: false });
+								}
+							}
 						}
 					}
 				};
 
 				upgrade.onsuccess = e => {
+					if (settled) {
+						if (e.target.result) e.target.result.close();
+						return;
+					}
+					if (blockedTimeout) clearTimeout(blockedTimeout);
+					settled = true;
 					const db = e.target.result;
 					_setupVersionChangeHandler(db);
 					_db = db;
@@ -771,7 +811,7 @@ import { aggregateRecords, decorateRecords, filterRecords, queryRecords } from '
 	_component.prototype.count = function (filters) {
 		const hasFilters = filters && Object.keys(filters).length > 0;
 		if (!hasFilters) {
-			if (this.totalCount != null) return Promise.resolve(this.totalCount);
+			if (this.windowed && this.totalCount != null) return Promise.resolve(this.totalCount);
 			return _countRecords(this._name);
 		}
 		return _getAllRecords(this._name).then(records => filterRecords(records, filters).length);
@@ -791,12 +831,12 @@ import { aggregateRecords, decorateRecords, filterRecords, queryRecords } from '
 		meta = meta || {};
 		const self = this;
 		if (self._windowIndex && meta.queryGen != null && meta.queryGen !== self._windowIndex.queryGen) {
-			return Promise.resolve();
+			return Promise.resolve({ ok: true, stale: true });
 		}
 
-		const hasChanges = upsertedRecords.length > 0 || deletedIds.length > 0;
-
-		let chain = Promise.resolve();
+		let chain = _getDb().then(db => {
+			if (!db) throw new Error('IndexedDB unavailable');
+		});
 		if (upsertedRecords.length > 0) chain = chain.then(() => _putBulk(self._name, upsertedRecords));
 		if (deletedIds.length > 0) chain = chain.then(() => _deleteBulk(self._name, deletedIds));
 
@@ -836,9 +876,16 @@ import { aggregateRecords, decorateRecords, filterRecords, queryRecords } from '
 					meta: meta
 				});
 			}
+			return { ok: true };
 		}).catch(err => {
 			self.isSyncing = false;
+			const errorMsg = (err && err.message) ? err.message : String(err);
 			console.error('[ln-data-store] applySync failed:', err);
+			dispatch(self.dom, 'ln-data-store:sync-error', {
+				store: self._name,
+				error: errorMsg
+			});
+			return normalizeSyncError(err);
 		});
 	};
 
@@ -957,14 +1004,14 @@ import { aggregateRecords, decorateRecords, filterRecords, queryRecords } from '
 
 	// The IndexedDB schema and the store's registered name are fixed at open
 	// time: createIndex is only legal inside a versionchange transaction
-	// (see onupgradeneeded, :85-94). A post-init edit is recorded on the host
+	// (see onupgradeneeded). A post-init edit is recorded on the host
 	// for the dev stylesheet to surface; nothing is applied.
 	function _markFrozen(el, attrName) {
 		el.setAttribute(FROZEN_ATTR, attrName);
 	}
 
 	// Shrinking the window drops positions; the records behind them stop being
-	// held, exactly as on ingest (:757-758), so they leave IndexedDB too.
+	// held, exactly as on ingest, so they leave IndexedDB too.
 	function _applyWindowSize(el) {
 		const inst = el[DOM_ATTRIBUTE];
 		if (!inst._windowIndex) return;

package/components/ln-date/README.md

@@ -207,3 +207,7 @@ On blur: empty → clear + dispatch; unchanged from the current formatted displa
 ### Observers
 
 A shared `document.body` `MutationObserver` auto-initializes new `[data-ln-date]` elements (`childList`) and re-initializes on `data-ln-date` attribute addition (`attributes`). A separate observer on `document.documentElement` watches `lang` and re-formats every active instance when it changes.
+
+### Teardown & Lifecycle (`destroy()`)
+
+When an element is destroyed, the component cleanly detaches the global `ln-core:locale-change` event listener regardless of whether the element is an input decorator or a static text display element (`<time>`, `<td>`, `<span>`). For inputs, wrapper children, blur/click listeners, and value interceptors are unhooked to prevent DOM leaks.