@livenetworks/ashlar 1.4.1 → 1.6.0

package/js/ln-core/hash.js

@@ -0,0 +1,92 @@
+// ─── Hash codec (URL fragment as namespaced state) ─────────
+//
+// Grammar:  #nsA:valA&nsB:valB
+// Each component owns ONE namespace, ignores all others, and PRESERVES
+// foreign segments on write — this is what makes component isolation work.
+//
+// Three-state value model:
+//   absent        → hashGet returns null   (e.g. closed)
+//   #ns           → hashGet returns ''      (present, no value — e.g. "new")
+//   #ns:val       → hashGet returns 'val'   (present, with param)
+//
+// Write mechanism: `location.hash =` (fires hashchange; identical value is a
+// no-op so there are no loops). Never pushState here.
+
+function _strip(str) {
+	return (str || '').replace(/^#/, '');
+}
+
+export function hashParse(str) {
+	const raw = (str === undefined) ? location.hash : str;
+	const map = {};
+	const h = _strip(raw);
+	if (!h) return map;
+	const parts = h.split('&');
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		if (!part) continue;
+		const sep = part.indexOf(':');
+		const ns = (sep > -1 ? part.slice(0, sep) : part);
+		const val = (sep > -1 ? part.slice(sep + 1) : '');
+		if (!ns) continue;
+		try { map[ns] = decodeURIComponent(val); }
+		catch (e) { map[ns] = val; }
+	}
+	return map;
+}
+
+export function hashGet(ns) {
+	if (!ns) return null;
+	const map = hashParse();
+	return (ns in map) ? map[ns] : null;
+}
+
+export function hashSet(ns, value) {
+	if (!ns) return;
+	const map = hashParse();
+	if (value === null || value === undefined) {
+		delete map[ns];
+	} else {
+		map[ns] = String(value);
+	}
+	const keys = Object.keys(map);
+	const next = keys.map(function (k) {
+		const v = map[k];
+		return (v === '') ? k : (k + ':' + encodeURIComponent(v));
+	}).join('&');
+	// Setting an identical hash is a no-op (no hashchange) → no loops.
+	if (_strip(location.hash) === next) return;
+	location.hash = next;
+}
+
+// ─── Hash-link click guard (shared by ln-tabs & ln-modal) ──
+//
+// A "hash link" is an <a href="#…"> whose click a component wants to drive
+// through the codec instead of native fragment navigation (native nav replaces
+// the WHOLE fragment and wipes foreign segments). Both ln-tabs and ln-modal
+// funnel their own anchor clicks through here so the guard + preventDefault
+// live in ONE place.
+//
+// Returns:
+//   false → modifier / middle / shift-click: caller must return and let the
+//           browser do native open-in-new-tab / new-window. No preventDefault.
+//   true  → ordinary click: preventDefault() has been called; caller proceeds
+//           with its OWN write (hashSet merge, or a component-specific branch
+//           such as ln-tabs' already-current setAttribute).
+//
+// Deliberately does NOT call hashSet — ln-tabs needs an "already-current value
+// → setAttribute active directly (no hash write)" branch, so the write differs
+// per component. The shared, reusable surface is the guard + preventDefault.
+export function hashLinkClick(e) {
+	if (e.button === 1 || e.ctrlKey || e.metaKey || e.shiftKey) return false;
+	e.preventDefault();
+	return true;
+}
+
+if (typeof window !== 'undefined') {
+	window.lnCore = window.lnCore || {};
+	window.lnCore.hashParse = hashParse;
+	window.lnCore.hashGet = hashGet;
+	window.lnCore.hashSet = hashSet;
+	window.lnCore.hashLinkClick = hashLinkClick;
+}

package/js/ln-core/helpers.js

@@ -1,3 +1,23 @@
+// ─── Global Console Warning Interceptor (Production Mode) ──
+if (typeof window !== 'undefined') {
+	const originalWarn = console.warn;
+	console.warn = function (...args) {
+		const isLibraryWarning = typeof args[0] === 'string' &&
+			(args[0].startsWith('[ln-') || args[0].startsWith('[lnCore'));
+
+		if (isLibraryWarning) {
+			const isDebug =
+				document.documentElement.hasAttribute('data-ln-debug') ||
+				(document.body && document.body.hasAttribute('data-ln-debug'));
+
+			if (!isDebug) {
+				return;
+			}
+		}
+		originalWarn.apply(console, args);
+	};
+}
+
 // ─── Template Cache ────────────────────────────────────────
 const _tmplCache = {};
 
@@ -36,6 +56,40 @@ export function dispatchCancelable(element, eventName, detail) {
 	return event;
 }
 
+/**
+ * Re-filter / re-sort / re-render a data-driven list-like component, then
+ * notify the coordinator that fresh data is requested.
+ *
+ * Shared by ln-list and ln-table. The passed `component` MUST expose this
+ * instance contract:
+ *   - _applyFilterAndSort()  method
+ *   - _render()              method
+ *   - _updateFooter()        method
+ *   - _vStart, _vEnd         number (reset to -1 to force a full re-render)
+ *   - dom                    the component root element (dispatch target)
+ *   - name                   the component's name (becomes detail[keyName])
+ *   - currentSort, currentFilters, currentSearch
+ *
+ * @param {Object} component  component instance satisfying the contract above
+ * @param {string} eventName  e.g. 'ln-table:request-data' / 'ln-list:request-data'
+ * @param {string} keyName    payload key for the name, e.g. 'table' / 'list'
+ */
+export function requestData(component, eventName, keyName) {
+	component._applyFilterAndSort();
+	component._vStart = -1;
+	component._vEnd = -1;
+	component._render();
+	component._updateFooter();
+
+	const detail = {
+		sort: component.currentSort,
+		filters: component.currentFilters,
+		search: component.currentSearch
+	};
+	detail[keyName] = component.name;
+	dispatch(component.dom, eventName, detail);
+}
+
 // ─── Declarative DOM Binding ───────────────────────────────
 
 export function fill(root, data) {
@@ -96,10 +150,54 @@ export function fill(root, data) {
 	return root;
 }
 
+// ─── Event-driven fill fan-out ─────────────────────────────
+
+/**
+ * Dispatch `ln-fill` at every [data-ln-form] and [data-ln-fillable]
+ * descendant of `container`. Fillables self-handle; null → clear/reset.
+ */
+export function lnFill(container, record) {
+	// Dispatch at container itself when it is a form or fillable.
+	// Enables lnFill(formEl, record) to reach ln-form's listener, which
+	// guards e.target === self.dom. Modal callers (lnFill(modalEl, …)
+	// where modalEl is [data-ln-modal]) do not match, so they are unaffected.
+	if (container.matches && container.matches('[data-ln-form], [data-ln-fillable]')) {
+		container.dispatchEvent(new CustomEvent('ln-fill', { detail: record ?? null, bubbles: true }));
+	}
+	const targets = container.querySelectorAll('[data-ln-form], [data-ln-fillable]');
+	for (let i = 0; i < targets.length; i++) {
+		targets[i].dispatchEvent(new CustomEvent('ln-fill', { detail: record ?? null, bubbles: true }));
+	}
+	return container;
+}
+
+// Delegated display-fillable handler — installed once per page (idempotent
+// across standalone component bundles that each inline ln-core helpers).
+// Forms are NOT [data-ln-fillable]; ln-form's own listener handles them.
+if (typeof window !== 'undefined') {
+	window.lnCore = window.lnCore || {};
+	if (!window.lnCore._fillBound) {
+		window.lnCore._fillBound = true;
+		document.addEventListener('ln-fill', function (e) {
+			if (!e.target.matches || !e.target.matches('[data-ln-fillable]')) return;
+			if (e.detail) {
+				fill(e.target, e.detail);
+			} else {
+				const fields = e.target.querySelectorAll('[data-ln-field]');
+				for (let i = 0; i < fields.length; i++) {
+					fields[i].textContent = '';
+				}
+			}
+		});
+	}
+}
+
 // ─── Template Text-Node Placeholders ──────────────────────
 
 export function fillTemplate(clone, data) {
 	if (!clone || !data) return clone;
+
+	// ── Pass 1: text nodes ──────────────────────────────────
 	const walker = document.createTreeWalker(clone, NodeFilter.SHOW_TEXT);
 	while (walker.nextNode()) {
 		const node = walker.currentNode;
@@ -110,6 +208,27 @@ export function fillTemplate(clone, data) {
 			);
 		}
 	}
+
+	// ── Pass 2: element attributes ──────────────────────────
+	// Uses setAttribute — never innerHTML — so injection risk is the same
+	// as data-ln-attr (the existing declarative attribute-fill mechanism).
+	// Complements data-ln-table-cell-attr (field→attr stamping); both coexist.
+	const _replaceTokens = function (_, key) { return data[key] !== undefined ? data[key] : ''; };
+	const elements = Array.from(clone.querySelectorAll('*'));
+	// Include the root itself when clone is an Element (e.g. a <tr> passed
+	// directly by ln-table._fillRow) — querySelectorAll does not include root.
+	if (clone.nodeType === 1) elements.push(clone);
+	for (let i = 0; i < elements.length; i++) {
+		const el = elements[i];
+		const attrs = el.attributes;
+		for (let j = 0; j < attrs.length; j++) {
+			const attr = attrs[j];
+			if (attr.value.indexOf('{{') !== -1) {
+				el.setAttribute(attr.name, attr.value.replace(/\{\{\s*(\w+)\s*\}\}/g, _replaceTokens));
+			}
+		}
+	}
+
 	return clone;
 }
 
@@ -223,17 +342,46 @@ export function isVisible(el) {
 
 // ─── Form Serialization ───────────────────────────────────
 
-export function serializeForm(form) {
+// Effective HTTP method for a form: hidden _method input (non-empty) wins,
+// else the form's own `method` attribute. Shared by ln-form's submit gate
+// and ln-data-coordinator's native-submit claim so both read the identical
+// literal DOM state — no drift between the two independent checks.
+export function resolveFormMethod(form) {
+	const methodInput = form.querySelector('input[name="_method"]');
+	const raw = (methodInput && methodInput.value !== '') ? methodInput.value : form.method;
+	return (raw || '').toUpperCase();
+}
+
+export function serializeForm(form, opts) {
+	const typed = !!(opts && opts.typed);
+	const exclude = opts && opts.exclude;
 	const data = {};
 	const elements = form.elements;
 
+	// Pre-count checkbox names in typed mode to distinguish single-checkbox
+	// (→ boolean) from same-name checkbox groups (→ array of checked values).
+	const checkboxCounts = {};
+	if (typed) {
+		for (let i = 0; i < elements.length; i++) {
+			const el = elements[i];
+			if (el.name && el.type === 'checkbox' && !el.disabled) {
+				checkboxCounts[el.name] = (checkboxCounts[el.name] || 0) + 1;
+			}
+		}
+	}
+
 	for (let i = 0; i < elements.length; i++) {
 		const el = elements[i];
 		if (!el.name || el.disabled || el.type === 'file' || el.type === 'submit' || el.type === 'button') continue;
+		if (exclude && el.matches && el.matches(exclude)) continue;
 
 		if (el.type === 'checkbox') {
-			if (!data[el.name]) data[el.name] = [];
-			if (el.checked) data[el.name].push(el.value);
+			if (typed && checkboxCounts[el.name] === 1) {
+				data[el.name] = el.checked;                          // single checkbox → boolean
+			} else {
+				if (!data[el.name]) data[el.name] = [];
+				if (el.checked) data[el.name].push(el.value);        // group → array (unchanged)
+			}
 		} else if (el.type === 'radio') {
 			if (el.checked) data[el.name] = el.value;
 		} else if (el.type === 'select-multiple') {
@@ -241,6 +389,11 @@ export function serializeForm(form) {
 			for (let j = 0; j < el.options.length; j++) {
 				if (el.options[j].selected) data[el.name].push(el.options[j].value);
 			}
+		} else if (typed && el.type === 'hidden') {
+			data[el.name] = el.value;                               // hidden → always string (never coerce)
+		} else if (typed && (el.type === 'number' || el.type === 'range')) {
+			const n = Number(el.value);
+			data[el.name] = (el.value === '' || isNaN(n)) ? null : n; // number/range → Number | null
 		} else {
 			data[el.name] = el.value;
 		}
@@ -249,18 +402,57 @@ export function serializeForm(form) {
 	return data;
 }
 
+// Coerce a value to boolean for single-checkbox fill.
+// Flat data-* values arrive as strings; "false", "0", "", "off", "no"
+// (case-insensitive, trimmed) are treated as unchecked.
+function _coerceBool(value) {
+	if (typeof value !== 'string') return !!value;
+	const v = value.trim().toLowerCase();
+	return v !== 'false' && v !== '0' && v !== '' && v !== 'off' && v !== 'no';
+}
+
 export function populateForm(form, data) {
 	const elements = form.elements;
 	const filled = [];
 
+	// Pre-count checkbox names to distinguish single-checkbox (→ bool)
+	// from same-name checkbox groups (→ comma-separated list membership).
+	// NOTE: unlike serializeForm, populateForm fills disabled elements too,
+	// so the count must include disabled members (no !el.disabled guard) —
+	// otherwise a group with a disabled box reverts to single-checkbox coercion.
+	const checkboxCounts = {};
 	for (let i = 0; i < elements.length; i++) {
 		const el = elements[i];
-		if (!el.name || !(el.name in data) || el.type === 'file' || el.type === 'submit' || el.type === 'button') continue;
+		if (el.name && el.type === 'checkbox') {
+			checkboxCounts[el.name] = (checkboxCounts[el.name] || 0) + 1;
+		}
+	}
 
-		const value = data[el.name];
+	for (let i = 0; i < elements.length; i++) {
+		const el = elements[i];
+		if (el.type === 'file' || el.type === 'submit' || el.type === 'button') continue;
+
+		// Decoupled-key fill: data-ln-fill-as wins over name for record matching.
+		// Write (fill) path only — serializeForm stays name-based.
+		const matchKey = el.getAttribute('data-ln-fill-as') || el.name;
+		if (!matchKey || !(matchKey in data)) continue;
+
+		const value = data[matchKey];
 
 		if (el.type === 'checkbox') {
-			el.checked = Array.isArray(value) ? value.indexOf(el.value) !== -1 : !!value;
+			if (Array.isArray(value)) {
+				// Programmatic array path — membership check.
+				el.checked = value.indexOf(el.value) !== -1;
+			} else if (checkboxCounts[el.name] > 1) {
+				// Same-name checkbox group + scalar: treat as comma-separated list.
+				// "admin,editor" → ['admin','editor'] → membership check.
+				const list = String(value).split(',').map(function (s) { return s.trim(); });
+				el.checked = list.indexOf(el.value) !== -1;
+			} else {
+				// Single checkbox — boolean coercion.
+				// "false"/"0"/"off"/"no"/"" → unchecked; anything else → checked.
+				el.checked = _coerceBool(value);
+			}
 			filled.push(el);
 		} else if (el.type === 'radio') {
 			el.checked = el.value === String(value);
@@ -283,9 +475,83 @@ export function populateForm(form, data) {
 
 // ─── Locale Detection ─────────────────────────────────────
 
+const _standardTerritories = {
+	mk: 'mk-MK',
+	de: 'de-DE',
+	fr: 'fr-FR',
+	es: 'es-ES',
+	it: 'it-IT',
+	nl: 'nl-NL',
+	pt: 'pt-PT',
+	ru: 'ru-RU',
+	bg: 'bg-BG',
+	hr: 'hr-HR',
+	sr: 'sr-RS',
+	sq: 'sq-AL',
+	el: 'el-GR',
+	en: 'en-US'
+};
+
 export function getLocale(el) {
-	const langEl = el.closest('[lang]');
-	return (langEl ? langEl.lang : null) || navigator.language;
+	const langEl = el ? el.closest('[lang]') : null;
+	const raw = (langEl ? (langEl.getAttribute('lang') || langEl.lang) : null)
+		|| (document.documentElement ? (document.documentElement.getAttribute('lang') || document.documentElement.lang) : null)
+		|| navigator.language;
+	if (!raw) return 'en-US';
+	const lower = raw.trim().toLowerCase();
+	if (lower.indexOf('-') === -1 && _standardTerritories[lower]) {
+		return _standardTerritories[lower];
+	}
+	return raw;
+}
+
+// ─── Raw Value Read ───────────────────────────────────────
+
+/**
+ * Read the raw machine value behind a formatted cell/item display.
+ * Returns the `data-ln-value` attribute if present, else trimmed textContent.
+ * Single read path for value-based sort/filter across components.
+ */
+export function readValue(el) {
+	return el.hasAttribute('data-ln-value')
+		? el.getAttribute('data-ln-value')
+		: el.textContent.trim();
+}
+
+// ─── Value Comparison Primitives ───────────────────────────
+
+/**
+ * Detect the comparison type for a column/field from its current value set.
+ * Type is locked ONCE per sort operation (not per pair) — comparing types
+ * per-pair breaks comparator transitivity and produces wrong ordering.
+ * All non-empty values must be finite numbers for 'number'; otherwise 'string'.
+ */
+export function detectValueType(values) {
+	let hasValue = false;
+	for (let i = 0; i < values.length; i++) {
+		const v = values[i];
+		if (v === '' || v == null) continue;
+		hasValue = true;
+		if (!Number.isFinite(Number(v))) return 'string';
+	}
+	return hasValue ? 'number' : 'string';
+}
+
+/**
+ * Compare two raw values given a pre-locked type (see detectValueType).
+ * Pass an Intl.Collator instance for locale-aware string comparison —
+ * built once by the caller outside the sort loop, never per pair.
+ */
+export function compareValues(a, b, type, collator) {
+	if (type === 'number') {
+		const na = parseFloat(a);
+		const nb = parseFloat(b);
+		return (isNaN(na) ? 0 : na) - (isNaN(nb) ? 0 : nb);
+	}
+	const strA = a != null ? String(a) : '';
+	const strB = b != null ? String(b) : '';
+	if (collator) return collator.compare(strA, strB);
+	return strA < strB ? -1 : strA > strB ? 1 : 0;
 }
 
 // ─── Value Property Interception ───────────────────────────
@@ -407,6 +673,30 @@ export function registerComponent(selector, attribute, ComponentFn, componentTag
 
 // ─── HTTP / URL Helpers ────────────────────────────────────
 
+/**
+ * Check if a click event on a link should be intercepted by an in-app navigator.
+ * Intercept only left clicks, same-origin, not target="_blank", no download,
+ * not mailto/tel, and not pure hash/empty.
+ *
+ * @param {MouseEvent} event
+ * @param {HTMLAnchorElement} anchor
+ * @returns {boolean}
+ */
+export function shouldInterceptLink(event, anchor) {
+	if (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey || event.button !== 0) {
+		return false;
+	}
+	if (!anchor) return false;
+	const href = anchor.getAttribute('href');
+	if (!href) return false;
+	if (anchor.getAttribute('target') === '_blank') return false;
+	if (anchor.hasAttribute('download')) return false;
+	if (href.startsWith('mailto:') || href.startsWith('tel:')) return false;
+	if (href === '#' || href.startsWith('#')) return false;
+	if (anchor.hostname && anchor.hostname !== window.location.hostname) return false;
+	return true;
+}
+
 /**
  * Build a URL from segments, stripping duplicate slashes.
  */
@@ -450,10 +740,49 @@ export function getDataMapper(name) {
 	return _dataMappers[name] || { ingress: r => r, egress: r => r };
 }
 
+// ─── 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;
+}
+
+// Default Macedonian locale fallback registration
+registerLocaleFallback('mk', {
+	monthsLong: [
+		'јануари', 'февруари', 'март', 'април', 'мај', 'јуни',
+		'јули', 'август', 'септември', 'октомври', 'ноември', 'декември'
+	],
+	monthsShort: [
+		'јан', 'фев', 'мар', 'апр', 'мај', 'јун',
+		'јул', 'авг', 'септ', 'окт', 'ноем', 'дек'
+	],
+	daysLong: [
+		'недела', 'понеделник', 'вторник', 'среда', 'четврток', 'петок', 'сабота'
+	],
+	daysShort: [
+		'нед', 'пон', 'вт', 'ср', 'чет', 'пет', 'саб'
+	]
+});
+
 if (typeof window !== 'undefined') {
 	window.lnCore = window.lnCore || {};
 	window.lnCore.registerDataMapper = registerDataMapper;
 	window.lnCore.getDataMapper = getDataMapper;
+	window.lnCore.registerLocaleFallback = registerLocaleFallback;
+	window.lnCore.getLocaleFallback = getLocaleFallback;
+	window.lnCore.fillTemplate = fillTemplate;
+	window.lnCore.fill = fill;
+	window.lnCore.lnFill = lnFill;
+	window.lnCore.renderList = renderList;
 }
 
 

package/js/ln-core/index.js

@@ -1,5 +1,7 @@
-export { cloneTemplate, cloneTemplateScoped, dispatch, dispatchCancelable, fill, fillTemplate, renderList, buildDict, guardBody, findElements, isVisible, serializeForm, populateForm, getLocale, registerComponent, buildUrl, getHeaders, parseHeaders, registerDataMapper, getDataMapper, interceptValueProperty } from './helpers.js';
+export { cloneTemplate, cloneTemplateScoped, dispatch, dispatchCancelable, requestData, fill, lnFill, fillTemplate, renderList, buildDict, guardBody, findElements, isVisible, serializeForm, populateForm, resolveFormMethod, getLocale, readValue, detectValueType, compareValues, registerComponent, shouldInterceptLink, buildUrl, getHeaders, parseHeaders, registerDataMapper, getDataMapper, interceptValueProperty, registerLocaleFallback, getLocaleFallback } from './helpers.js';
 export { reactiveState, deepReactive, createBatcher } from './reactive.js';
+export { createWindowCache } from './window-cache.js';
 export { persistGet, persistSet, persistRemove, persistClear } from './persist.js';
-export { computePlacement, teleportToBody, measureHidden } from './positioning.js';
+export { hashParse, hashGet, hashSet, hashLinkClick } from './hash.js';
+export { computePlacement, measureHidden } from './positioning.js';
 export { setCryptoKey, getCryptoKey, encryptData, decryptData } from './crypto.js';

package/js/ln-core/persist.js

@@ -3,7 +3,7 @@
 // Key format: ln:{component}:{pathname}:{elementId}
 // Example:    ln:filter:/admin/users:status-filter
 //
-// Each component passes its own name ("filter", "table-sort", "toggle", "tabs"),
+// Each component passes its own name ("filter", "sort", "toggle", "tabs"),
 // so keys are namespaced per component — no cross-component collision risk.
 // Element ID comes from data-ln-persist="key" or el.id.
 //
@@ -12,6 +12,24 @@
 
 const PREFIX = 'ln:';
 
+let _isStorageAvailable = null;
+function _checkStorage() {
+	if (_isStorageAvailable !== null) return _isStorageAvailable;
+	try {
+		if (typeof localStorage === 'undefined') {
+			_isStorageAvailable = false;
+			return false;
+		}
+		const testKey = '__ln_test__';
+		localStorage.setItem(testKey, testKey);
+		localStorage.removeItem(testKey);
+		_isStorageAvailable = true;
+	} catch (e) {
+		_isStorageAvailable = false;
+	}
+	return _isStorageAvailable;
+}
+
 function _pageKey() {
 	const path = location.pathname.replace(/\/+$/, '').toLowerCase();
 	return path || '/';
@@ -28,6 +46,7 @@ function _resolveKey(component, el) {
 }
 
 export function persistGet(component, el) {
+	if (!_checkStorage()) return null;
 	const key = _resolveKey(component, el);
 	if (!key) return null;
 	try {
@@ -39,16 +58,22 @@ export function persistGet(component, el) {
 }
 
 export function persistSet(component, el, value) {
+	if (!_checkStorage()) return;
 	const key = _resolveKey(component, el);
 	if (!key) return;
 	try {
-		localStorage.setItem(key, JSON.stringify(value));
+		if (value === null || value === undefined) {
+			localStorage.removeItem(key);
+		} else {
+			localStorage.setItem(key, JSON.stringify(value));
+		}
 	} catch (e) {
-		// localStorage full or disabled — silent
+		// localStorage full — silent
 	}
 }
 
 export function persistRemove(component, el) {
+	if (!_checkStorage()) return;
 	const key = _resolveKey(component, el);
 	if (!key) return;
 	try {
@@ -57,6 +82,7 @@ export function persistRemove(component, el) {
 }
 
 export function persistClear(component) {
+	if (!_checkStorage()) return;
 	try {
 		const prefix = PREFIX + component + ':';
 		const toRemove = [];

package/js/ln-core/positioning.js

@@ -2,8 +2,7 @@
 //
 // Pure helpers for floating UI (popovers, tooltips, dropdowns).
 // No DOM side effects in computePlacement — it takes a rect and
-// returns coordinates. teleportToBody and measureHidden touch DOM
-// because they have to.
+// returns coordinates. measureHidden touches DOM because it has to.
 
 /**
  * Compute viewport coordinates for a floating element relative to an
@@ -138,39 +137,6 @@ export function computePlacement(anchorRect, floatingSize, preferred, offset) {
 	return { top: top, left: left, placement: chosen.side };
 }
 
-/**
- * Move an element into <body>, leaving a placeholder comment so
- * teleportBack can put it back exactly where it was. Returns a
- * cleanup function — call it to restore the element to its origin.
- *
- * The element receives `position: fixed` style automatically (the
- * caller is responsible for top/left). To avoid violating the
- * "no inline styles" rule, the caller should set position via a
- * CSS rule on its component selector (e.g. [data-ln-popover]
- * already has position: fixed in its co-located scss). teleportToBody
- * itself does NOT set any inline styles.
- *
- * @param {HTMLElement} el
- * @returns {Function} cleanup — restores el to its original parent.
- */
-export function teleportToBody(el) {
-	if (!el || el.parentNode === document.body) {
-		// Already in body or no element — return a no-op cleanup.
-		return function () {};
-	}
-
-	const originalParent = el.parentNode;
-	const placeholder = document.createComment('ln-teleport');
-	originalParent.insertBefore(placeholder, el);
-	document.body.appendChild(el);
-
-	return function restore() {
-		if (!placeholder.parentNode) return;
-		placeholder.parentNode.insertBefore(el, placeholder);
-		placeholder.parentNode.removeChild(placeholder);
-	};
-}
-
 /**
  * Measure an element that may be hidden via display:none.
  * Temporarily applies visibility:hidden + display:block so we can