@livenetworks/ashlar 2.0.7 → 2.0.9

package/components/ln-core/http.js

@@ -1,48 +1,48 @@
-/**
- * Build a URL from segments, stripping duplicate slashes.
- */
-export function buildUrl(...segments) {
-	return segments
-		.filter(x => x !== undefined && x !== null && x !== '')
-		.map((part, index) => {
-			if (index === 0) return part.replace(/\/+$/, '');
-			return part.replace(/^\/+/, '').replace(/\/+$/, '');
-		})
-		.filter(Boolean)
-		.join('/');
-}
-
-/**
- * Compile standard JSON request headers.
- */
-export function getHeaders(customHeaders, auth) {
-	return Object.assign({
-		'Content-Type': 'application/json',
-		'Accept': 'application/json'
-	}, customHeaders, auth ? { 'Authorization': auth } : null);
-}
-
-/**
- * Safely parse headers from JSON string.
- */
-export function parseHeaders(str, componentName = 'ln-core') {
-	try { return str ? JSON.parse(str) : {}; }
-	catch (e) { return console.error(`[${componentName}] Invalid headers JSON:`, e), {}; }
-}
-
-// ─── Domain Data Mapper Registry ───────────────────────────
-const _dataMappers = {};
-
-export function registerDataMapper(name, mapper) {
-	_dataMappers[name] = mapper;
-}
-
-export function getDataMapper(name) {
-	return _dataMappers[name] || { ingress: r => r, egress: r => r };
-}
-
-if (typeof window !== 'undefined') {
-	window.lnCore = window.lnCore || {};
-	window.lnCore.registerDataMapper = registerDataMapper;
-	window.lnCore.getDataMapper = getDataMapper;
-}
+/**
+ * Build a URL from segments, stripping duplicate slashes.
+ */
+export function buildUrl(...segments) {
+	return segments
+		.filter(x => x !== undefined && x !== null && x !== '')
+		.map((part, index) => {
+			if (index === 0) return part.replace(/\/+$/, '');
+			return part.replace(/^\/+/, '').replace(/\/+$/, '');
+		})
+		.filter(Boolean)
+		.join('/');
+}
+
+/**
+ * Compile standard JSON request headers.
+ */
+export function getHeaders(customHeaders, auth) {
+	return Object.assign({
+		'Content-Type': 'application/json',
+		'Accept': 'application/json'
+	}, customHeaders, auth ? { 'Authorization': auth } : null);
+}
+
+/**
+ * Safely parse headers from JSON string.
+ */
+export function parseHeaders(str, componentName = 'ln-core') {
+	try { return str ? JSON.parse(str) : {}; }
+	catch (e) { return console.error(`[${componentName}] Invalid headers JSON:`, e), {}; }
+}
+
+// ─── Domain Data Mapper Registry ───────────────────────────
+const _dataMappers = {};
+
+export function registerDataMapper(name, mapper) {
+	_dataMappers[name] = mapper;
+}
+
+export function getDataMapper(name) {
+	return _dataMappers[name] || { ingress: r => r, egress: r => r };
+}
+
+if (typeof window !== 'undefined') {
+	window.lnCore = window.lnCore || {};
+	window.lnCore.registerDataMapper = registerDataMapper;
+	window.lnCore.getDataMapper = getDataMapper;
+}

package/components/ln-core/index.js

@@ -3,7 +3,7 @@ export { reactiveState, deepReactive, createBatcher } from './reactive.js';
 export { createWindowCache } from './window-cache.js';
 export { hashParse, hashGet, hashSet, hashLinkClick, resolveHashNamespace, hashSortEncode, hashSortDecode, hashFilterEncode, hashFilterDecode } from './hash.js';
 export { computePlacement, measureHidden } from './positioning.js';
-export { setCryptoKey, getCryptoKey, clearCryptoKey, hasCryptoKey, deriveCryptoKey, encryptData, decryptData, uint8ToBase64, base64ToUint8 } from './crypto.js';
+export { setCryptoKey, getCryptoKey, clearCryptoKey, hasCryptoKey, deriveCryptoKey, encryptData, decryptData, uint8ToBase64, base64ToUint8, uuid } from './crypto.js';
 export { calculateProgress } from './progress.js';
 export { parseDateInput, formatDateToISO } from './date.js';
 export { getSeparators, cleanNumericString, parseNumber, formatNumber } from './number.js';

package/components/ln-core/lifecycle.js

@@ -385,6 +385,11 @@ export function registerComponent(selector, attribute, ComponentFn, componentTag
 
 	window[attribute] = constructor;
 
+	if (typeof window !== 'undefined') {
+		window.lnCore = window.lnCore || {};
+		window.lnCore.registerComponent = registerComponent;
+	}
+
 	function boot() {
 		if (pendingCount() > 0) {
 			queueBoot(function () { constructor(document.body); });

package/components/ln-core/ln-core.schema.json

@@ -100,9 +100,10 @@
 			]
 		},
 		"data-ln-value": {
-			"direction": "author",
+			"direction": "both",
 			"sources": [
-				"dom.js"
+				"dom.js",
+				"form.js"
 			]
 		}
 	}

package/components/ln-core/locale.js

@@ -1,55 +1,55 @@
-import { dispatch } from './events.js';
-import { guardBody } from './dom.js';
-
-// ─── Locale Detection ─────────────────────────────────────
-
-export function getLocale(el) {
-	const langEl = el ? el.closest('[lang]') : null;
-	const raw = (langEl ? (langEl.getAttribute('lang') || langEl.lang) : null)
-		|| (typeof document !== 'undefined' && document.documentElement ? (document.documentElement.getAttribute('lang') || document.documentElement.lang) : null)
-		|| (typeof navigator !== 'undefined' ? navigator.language : null);
-	return raw ? raw.trim() : 'en-US';
-}
-
-// ─── Shared Locale-Change Broadcaster ─────────────────────
-
-export function ensureLocaleObserver() {
-	if (typeof window === 'undefined') return;
-	window.lnCore = window.lnCore || {};
-	if (window.lnCore._localeObserverBound) return;
-	window.lnCore._localeObserverBound = true;
-
-	guardBody(function () {
-		const observer = new MutationObserver(function () {
-			dispatch(document, 'ln-core:locale-change', {});
-		});
-		observer.observe(document.documentElement, {
-			attributes: true,
-			attributeFilter: ['lang'],
-			subtree: true
-		});
-	}, 'ln-core');
-}
-
-// ─── Locale Fallback Registry ───────────────────────────────
-const _localeFallbacks = {};
-
-export function registerLocaleFallback(langPrefix, dictionary) {
-	if (!langPrefix || typeof dictionary !== 'object') return;
-	const prefix = langPrefix.toLowerCase().split('-')[0];
-	_localeFallbacks[prefix] = dictionary;
-}
-
-export function getLocaleFallback(lang) {
-	if (!lang) return null;
-	const prefix = lang.toLowerCase().split('-')[0];
-	return _localeFallbacks[prefix] || null;
-}
-
-
-if (typeof window !== 'undefined') {
-	window.lnCore = window.lnCore || {};
-	window.lnCore.registerLocaleFallback = registerLocaleFallback;
-	window.lnCore.getLocaleFallback = getLocaleFallback;
-	window.lnCore.ensureLocaleObserver = ensureLocaleObserver;
-}
+import { dispatch } from './events.js';
+import { guardBody } from './dom.js';
+
+// ─── Locale Detection ─────────────────────────────────────
+
+export function getLocale(el) {
+	const langEl = el ? el.closest('[lang]') : null;
+	const raw = (langEl ? (langEl.getAttribute('lang') || langEl.lang) : null)
+		|| (typeof document !== 'undefined' && document.documentElement ? (document.documentElement.getAttribute('lang') || document.documentElement.lang) : null)
+		|| (typeof navigator !== 'undefined' ? navigator.language : null);
+	return raw ? raw.trim() : 'en-US';
+}
+
+// ─── Shared Locale-Change Broadcaster ─────────────────────
+
+export function ensureLocaleObserver() {
+	if (typeof window === 'undefined') return;
+	window.lnCore = window.lnCore || {};
+	if (window.lnCore._localeObserverBound) return;
+	window.lnCore._localeObserverBound = true;
+
+	guardBody(function () {
+		const observer = new MutationObserver(function () {
+			dispatch(document, 'ln-core:locale-change', {});
+		});
+		observer.observe(document.documentElement, {
+			attributes: true,
+			attributeFilter: ['lang'],
+			subtree: true
+		});
+	}, 'ln-core');
+}
+
+// ─── Locale Fallback Registry ───────────────────────────────
+const _localeFallbacks = {};
+
+export function registerLocaleFallback(langPrefix, dictionary) {
+	if (!langPrefix || typeof dictionary !== 'object') return;
+	const prefix = langPrefix.toLowerCase().split('-')[0];
+	_localeFallbacks[prefix] = dictionary;
+}
+
+export function getLocaleFallback(lang) {
+	if (!lang) return null;
+	const prefix = lang.toLowerCase().split('-')[0];
+	return _localeFallbacks[prefix] || null;
+}
+
+
+if (typeof window !== 'undefined') {
+	window.lnCore = window.lnCore || {};
+	window.lnCore.registerLocaleFallback = registerLocaleFallback;
+	window.lnCore.getLocaleFallback = getLocaleFallback;
+	window.lnCore.ensureLocaleObserver = ensureLocaleObserver;
+}

package/components/ln-core/matching.js

@@ -1,78 +1,78 @@
-/**
- * Normalizes a search query string for matching.
- * @param {unknown} value
- * @returns {string}
- */
-export function normalizeSearchTerm(value) {
-	return String(value || '').trim().toLowerCase();
-}
-
-/**
- * Splits query string into individual tokens for AND-based substring matching.
- * @param {unknown} term
- * @returns {string[]}
- */
-export function tokenizeSearchQuery(term) {
-	const normalized = normalizeSearchTerm(term);
-	if (!normalized) return [];
-	return normalized.split(/\s+/).filter(Boolean);
-}
-
-/**
- * Parses comma-separated field selectors forwarded to consumers.
- * @param {unknown} rawFields
- * @returns {string[]|null}
- */
-export function parseSearchFields(rawFields) {
-	if (rawFields === null || rawFields === undefined) return null;
-	const fields = String(rawFields)
-		.split(',')
-		.map(f => f.trim())
-		.filter(Boolean);
-	return fields.length ? fields : null;
-}
-
-/**
- * Checks if text contains all tokens (AND-matching, order-independent).
- * @param {string} text
- * @param {string[]} tokens
- * @returns {boolean}
- */
-export function matchesSearchTokens(text, tokens) {
-	if (!tokens || tokens.length === 0) return true;
-	if (!text) return false;
-	const lower = String(text).toLowerCase();
-	for (let i = 0; i < tokens.length; i++) {
-		if (lower.indexOf(tokens[i]) === -1) return false;
-	}
-	return true;
-}
-
-/**
- * Collapses collected text parts into normalized search index text.
- * @param {string[]} parts
- * @returns {string}
- */
-export function collapseSearchParts(parts) {
-	if (!parts || parts.length === 0) return '';
-	return parts.join(' ').replace(/\s+/g, ' ').trim().toLowerCase();
-}
-
-/**
- * Evaluates whether a cell or attribute value matches any of the filter's values (OR logic).
- * @param {unknown} value
- * @param {string[]} filterValues
- * @returns {boolean}
- */
-export function matchesFilterValues(value, filterValues) {
-	if (!filterValues || filterValues.length === 0) return true;
-	if (value === null || value === undefined) return false;
-
-	const lowerVal = String(value).trim().toLowerCase();
-	for (let i = 0; i < filterValues.length; i++) {
-		if (String(filterValues[i]).trim().toLowerCase() === lowerVal) {
-			return true;
-		}
-	}
-	return false;
-}
+/**
+ * Normalizes a search query string for matching.
+ * @param {unknown} value
+ * @returns {string}
+ */
+export function normalizeSearchTerm(value) {
+	return String(value || '').trim().toLowerCase();
+}
+
+/**
+ * Splits query string into individual tokens for AND-based substring matching.
+ * @param {unknown} term
+ * @returns {string[]}
+ */
+export function tokenizeSearchQuery(term) {
+	const normalized = normalizeSearchTerm(term);
+	if (!normalized) return [];
+	return normalized.split(/\s+/).filter(Boolean);
+}
+
+/**
+ * Parses comma-separated field selectors forwarded to consumers.
+ * @param {unknown} rawFields
+ * @returns {string[]|null}
+ */
+export function parseSearchFields(rawFields) {
+	if (rawFields === null || rawFields === undefined) return null;
+	const fields = String(rawFields)
+		.split(',')
+		.map(f => f.trim())
+		.filter(Boolean);
+	return fields.length ? fields : null;
+}
+
+/**
+ * Checks if text contains all tokens (AND-matching, order-independent).
+ * @param {string} text
+ * @param {string[]} tokens
+ * @returns {boolean}
+ */
+export function matchesSearchTokens(text, tokens) {
+	if (!tokens || tokens.length === 0) return true;
+	if (!text) return false;
+	const lower = String(text).toLowerCase();
+	for (let i = 0; i < tokens.length; i++) {
+		if (lower.indexOf(tokens[i]) === -1) return false;
+	}
+	return true;
+}
+
+/**
+ * Collapses collected text parts into normalized search index text.
+ * @param {string[]} parts
+ * @returns {string}
+ */
+export function collapseSearchParts(parts) {
+	if (!parts || parts.length === 0) return '';
+	return parts.join(' ').replace(/\s+/g, ' ').trim().toLowerCase();
+}
+
+/**
+ * Evaluates whether a cell or attribute value matches any of the filter's values (OR logic).
+ * @param {unknown} value
+ * @param {string[]} filterValues
+ * @returns {boolean}
+ */
+export function matchesFilterValues(value, filterValues) {
+	if (!filterValues || filterValues.length === 0) return true;
+	if (value === null || value === undefined) return false;
+
+	const lowerVal = String(value).trim().toLowerCase();
+	for (let i = 0; i < filterValues.length; i++) {
+		if (String(filterValues[i]).trim().toLowerCase() === lowerVal) {
+			return true;
+		}
+	}
+	return false;
+}

package/components/ln-core/number.js

@@ -1,125 +1,125 @@
-const _formatterCache = {};
-
-/**
- * Extract group and decimal separators dynamically from Intl.NumberFormat.
- * Supports standard commas, dots, and unicode narrow no-break space (U+202F) for fr-FR.
- *
- * @param {string} locale BCP 47 locale tag (e.g. 'en-US', 'mk-MK', 'fr-FR')
- * @returns {{ groupSep: string, decimalSep: string, fmt: Intl.NumberFormat }}
- */
-export function getSeparators(locale) {
-	const key = locale || 'default';
-	if (!_formatterCache[key]) {
-		const fmt = new Intl.NumberFormat(locale, { useGrouping: true });
-		const parts = fmt.formatToParts(1234.5);
-		let groupSep = '';
-		let decimalSep = '.';
-		for (let i = 0; i < parts.length; i++) {
-			if (parts[i].type === 'group') groupSep = parts[i].value;
-			if (parts[i].type === 'decimal') decimalSep = parts[i].value;
-		}
-		_formatterCache[key] = { groupSep, decimalSep, fmt };
-	}
-	return _formatterCache[key];
-}
-
-/**
- * Clean a numeric string by removing group separators, unicode spaces,
- * and normalizing the decimal separator to a period ('.').
- *
- * @param {string} raw Raw user input or string representation
- * @param {string} groupSep Group (thousands) separator
- * @param {string} decimalSep Decimal separator
- * @returns {string} Standardized numeric string (e.g. "1234.56" or "-10")
- */
-export function cleanNumericString(raw, groupSep, decimalSep) {
-	if (raw == null || typeof raw !== 'string') return '';
-	let str = raw.trim();
-	if (str === '') return '';
-
-	// Remove common currency symbols
-	str = str.replace(/[$€£¥]/g, '');
-
-	// Remove group separators if present
-	if (groupSep) {
-		str = str.split(groupSep).join('');
-	}
-
-	// Remove all Unicode whitespace characters (covers space, U+00A0, U+202F, etc.)
-	str = str.replace(/\s/g, '');
-
-	// Normalize decimal separator to '.'
-	if (decimalSep && decimalSep !== '.') {
-		str = str.replace(decimalSep, '.');
-	}
-
-	// Strip any remaining characters except digits, minus, and dot
-	str = str.replace(/[^\d.-]/g, '');
-
-	return str;
-}
-
-/**
- * Parse a localized numeric string or raw value into a valid floating-point number.
- *
- * @param {unknown} raw Raw string or number
- * @param {string} locale BCP 47 locale tag
- * @returns {number} Parsed float or NaN if invalid
- */
-export function parseNumber(raw, locale) {
-	if (typeof raw === 'number') return isNaN(raw) ? NaN : raw;
-	if (raw == null || typeof raw !== 'string') return NaN;
-	const trimmed = raw.trim();
-	if (trimmed === '' || trimmed === '-') return NaN;
-
-	const info = getSeparators(locale);
-	const cleaned = cleanNumericString(trimmed, info.groupSep, info.decimalSep);
-	if (cleaned === '' || cleaned === '-') return NaN;
-
-	const num = parseFloat(cleaned);
-	return isNaN(num) ? NaN : num;
-}
-
-/**
- * Format a number using Intl.NumberFormat according to specified locale and options.
- *
- * @param {number} num Number to format
- * @param {string} [locale='default'] BCP 47 locale tag
- * @param {Object} [options] Formatting options
- * @param {number|null} [options.maxDecimals] Maximum fraction digits limit
- * @param {number} [options.userDecimals] Exact fraction digits to preserve during typing
- * @returns {string} Formatted number string
- */
-export function formatNumber(num, locale, options = {}) {
-	if (typeof num !== 'number' || isNaN(num) || !Number.isFinite(num)) return '';
-
-	const loc = locale || 'default';
-	const maxDecimals = options.maxDecimals != null ? parseInt(options.maxDecimals, 10) : null;
-	const userDecimals = options.userDecimals != null ? options.userDecimals : null;
-
-	if (maxDecimals !== null) {
-		const cacheKey = loc + '|max:' + maxDecimals;
-		if (!_formatterCache[cacheKey]) {
-			_formatterCache[cacheKey] = new Intl.NumberFormat(locale, {
-				useGrouping: true,
-				minimumFractionDigits: 0,
-				maximumFractionDigits: maxDecimals
-			});
-		}
-		return _formatterCache[cacheKey].format(num);
-	}
-
-	if (userDecimals !== null && userDecimals > 0) {
-		const cacheKey = loc + '|exact:' + userDecimals;
-		if (!_formatterCache[cacheKey]) {
-			_formatterCache[cacheKey] = new Intl.NumberFormat(locale, {
-				useGrouping: true,
-				minimumFractionDigits: userDecimals,
-				maximumFractionDigits: userDecimals
-			});
-		}
-		return _formatterCache[cacheKey].format(num);
-	}
-
-	return getSeparators(locale).fmt.format(num);
-}
+const _formatterCache = {};
+
+/**
+ * Extract group and decimal separators dynamically from Intl.NumberFormat.
+ * Supports standard commas, dots, and unicode narrow no-break space (U+202F) for fr-FR.
+ *
+ * @param {string} locale BCP 47 locale tag (e.g. 'en-US', 'mk-MK', 'fr-FR')
+ * @returns {{ groupSep: string, decimalSep: string, fmt: Intl.NumberFormat }}
+ */
+export function getSeparators(locale) {
+	const key = locale || 'default';
+	if (!_formatterCache[key]) {
+		const fmt = new Intl.NumberFormat(locale, { useGrouping: true });
+		const parts = fmt.formatToParts(1234.5);
+		let groupSep = '';
+		let decimalSep = '.';
+		for (let i = 0; i < parts.length; i++) {
+			if (parts[i].type === 'group') groupSep = parts[i].value;
+			if (parts[i].type === 'decimal') decimalSep = parts[i].value;
+		}
+		_formatterCache[key] = { groupSep, decimalSep, fmt };
+	}
+	return _formatterCache[key];
+}
+
+/**
+ * Clean a numeric string by removing group separators, unicode spaces,
+ * and normalizing the decimal separator to a period ('.').
+ *
+ * @param {string} raw Raw user input or string representation
+ * @param {string} groupSep Group (thousands) separator
+ * @param {string} decimalSep Decimal separator
+ * @returns {string} Standardized numeric string (e.g. "1234.56" or "-10")
+ */
+export function cleanNumericString(raw, groupSep, decimalSep) {
+	if (raw == null || typeof raw !== 'string') return '';
+	let str = raw.trim();
+	if (str === '') return '';
+
+	// Remove common currency symbols
+	str = str.replace(/[$€£¥]/g, '');
+
+	// Remove group separators if present
+	if (groupSep) {
+		str = str.split(groupSep).join('');
+	}
+
+	// Remove all Unicode whitespace characters (covers space, U+00A0, U+202F, etc.)
+	str = str.replace(/\s/g, '');
+
+	// Normalize decimal separator to '.'
+	if (decimalSep && decimalSep !== '.') {
+		str = str.replace(decimalSep, '.');
+	}
+
+	// Strip any remaining characters except digits, minus, and dot
+	str = str.replace(/[^\d.-]/g, '');
+
+	return str;
+}
+
+/**
+ * Parse a localized numeric string or raw value into a valid floating-point number.
+ *
+ * @param {unknown} raw Raw string or number
+ * @param {string} locale BCP 47 locale tag
+ * @returns {number} Parsed float or NaN if invalid
+ */
+export function parseNumber(raw, locale) {
+	if (typeof raw === 'number') return isNaN(raw) ? NaN : raw;
+	if (raw == null || typeof raw !== 'string') return NaN;
+	const trimmed = raw.trim();
+	if (trimmed === '' || trimmed === '-') return NaN;
+
+	const info = getSeparators(locale);
+	const cleaned = cleanNumericString(trimmed, info.groupSep, info.decimalSep);
+	if (cleaned === '' || cleaned === '-') return NaN;
+
+	const num = parseFloat(cleaned);
+	return isNaN(num) ? NaN : num;
+}
+
+/**
+ * Format a number using Intl.NumberFormat according to specified locale and options.
+ *
+ * @param {number} num Number to format
+ * @param {string} [locale='default'] BCP 47 locale tag
+ * @param {Object} [options] Formatting options
+ * @param {number|null} [options.maxDecimals] Maximum fraction digits limit
+ * @param {number} [options.userDecimals] Exact fraction digits to preserve during typing
+ * @returns {string} Formatted number string
+ */
+export function formatNumber(num, locale, options = {}) {
+	if (typeof num !== 'number' || isNaN(num) || !Number.isFinite(num)) return '';
+
+	const loc = locale || 'default';
+	const maxDecimals = options.maxDecimals != null ? parseInt(options.maxDecimals, 10) : null;
+	const userDecimals = options.userDecimals != null ? options.userDecimals : null;
+
+	if (maxDecimals !== null) {
+		const cacheKey = loc + '|max:' + maxDecimals;
+		if (!_formatterCache[cacheKey]) {
+			_formatterCache[cacheKey] = new Intl.NumberFormat(locale, {
+				useGrouping: true,
+				minimumFractionDigits: 0,
+				maximumFractionDigits: maxDecimals
+			});
+		}
+		return _formatterCache[cacheKey].format(num);
+	}
+
+	if (userDecimals !== null && userDecimals > 0) {
+		const cacheKey = loc + '|exact:' + userDecimals;
+		if (!_formatterCache[cacheKey]) {
+			_formatterCache[cacheKey] = new Intl.NumberFormat(locale, {
+				useGrouping: true,
+				minimumFractionDigits: userDecimals,
+				maximumFractionDigits: userDecimals
+			});
+		}
+		return _formatterCache[cacheKey].format(num);
+	}
+
+	return getSeparators(locale).fmt.format(num);
+}