@santi020k/lumen-core 3.0.1 → 4.0.0

package/dist/media-workspace.js

@@ -0,0 +1,83 @@
+const assertMediaIdentities = (items) => {
+    const ids = new Set();
+    for (const item of items) {
+        if (!item.id.trim() || ids.has(item.id))
+            throw new Error('Media items require nonempty, unique IDs');
+        ids.add(item.id);
+    }
+};
+/** Returns a new collection; stale requests and out-of-range destinations leave its order intact. */
+export const moveLumenMediaItem = (items, id, targetIndex) => {
+    assertMediaIdentities(items);
+    const next = [...items];
+    const from = items.findIndex(item => item.id === id);
+    const item = items[from];
+    const validTarget = Number.isInteger(targetIndex) && targetIndex >= 0 && targetIndex < items.length;
+    if (!item || item.disabled || !validTarget)
+        return next;
+    next.splice(from, 1);
+    next.splice(targetIndex, 0, item);
+    return next;
+};
+/** Prunes missing IDs and duplicates, preserving the displayed media order. */
+export const resolveLumenMediaSelection = (items, selectedIds) => {
+    assertMediaIdentities(items);
+    const selected = new Set(selectedIds);
+    return items.filter(item => selected.has(item.id)).map(item => item.id);
+};
+export const toggleLumenMediaSelection = (items, selectedIds, id) => {
+    const selected = new Set(resolveLumenMediaSelection(items, selectedIds));
+    const item = items.find(candidate => candidate.id === id);
+    if (!item || item.disabled)
+        return [...selected];
+    if (selected.has(id))
+        selected.delete(id);
+    else
+        selected.add(id);
+    return resolveLumenMediaSelection(items, [...selected]);
+};
+export const resolveLumenMediaMaxZoom = (maxZoom = 4) => (Number.isFinite(maxZoom) ? Math.min(16, Math.max(1, maxZoom)) : 4);
+const panFraction = (value = 0) => Number.isFinite(value) ? Math.max(-1, Math.min(1, value)) : 0;
+const viewportNumber = (value, fallback = 0) => typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+const isViewportRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+export const normalizeLumenMediaViewport = (value = {}, maxZoom = 4) => {
+    if (!isViewportRecord(value))
+        return { x: 0, y: 0, zoom: 1 };
+    const limit = resolveLumenMediaMaxZoom(maxZoom);
+    const zoom = Math.min(limit, Math.max(1, viewportNumber(value.zoom, 1)));
+    const x = panFraction(viewportNumber(value.x));
+    const y = panFraction(viewportNumber(value.y));
+    return { x: zoom === 1 ? 0 : x, y: zoom === 1 ? 0 : y, zoom };
+};
+export const applyLumenMediaViewportAction = (value, action, maxZoom = 4) => {
+    const current = normalizeLumenMediaViewport(value, maxZoom);
+    if (action === 'fit')
+        return { x: 0, y: 0, zoom: 1 };
+    switch (action) {
+        case 'zoom-in': return normalizeLumenMediaViewport({ ...current, zoom: current.zoom + 0.25 }, maxZoom);
+        case 'zoom-out': return normalizeLumenMediaViewport({ ...current, zoom: current.zoom - 0.25 }, maxZoom);
+        case 'left': return normalizeLumenMediaViewport({ ...current, x: current.x - 0.25 }, maxZoom);
+        case 'right': return normalizeLumenMediaViewport({ ...current, x: current.x + 0.25 }, maxZoom);
+        case 'up': return normalizeLumenMediaViewport({ ...current, y: current.y - 0.25 }, maxZoom);
+        case 'down': return normalizeLumenMediaViewport({ ...current, y: current.y + 0.25 }, maxZoom);
+    }
+};
+/** Maps pointer movement to bounded pan coordinates without allowing media outside its viewport. */
+export const panLumenMediaViewport = (value, deltaX, deltaY, width, height, maxZoom = 4) => {
+    const current = normalizeLumenMediaViewport(value, maxZoom);
+    const extent = (current.zoom - 1) / 2;
+    if (extent === 0 || !Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0)
+        return current;
+    return normalizeLumenMediaViewport({
+        ...current,
+        x: current.x + (Number.isFinite(deltaX) ? deltaX / width / extent : 0),
+        y: current.y + (Number.isFinite(deltaY) ? deltaY / height / extent : 0)
+    }, maxZoom);
+};
+export const resolveLumenMediaThumbnailState = (state) => (state === 'loading' || state === 'error' ? state : 'ready');
+export const resolveLumenMediaOrder = (order) => (order !== undefined && Number.isSafeInteger(order) && order > 0 ? order : undefined);
+export const formatLumenMediaThumbnailState = (state, label) => {
+    if (label !== undefined)
+        return label;
+    return state === 'loading' ? 'Loading' : 'Unavailable';
+};

package/dist/message-scroller.d.ts

@@ -0,0 +1,14 @@
+export interface LumenMessageScrollState {
+    atEnd: boolean;
+}
+export interface LumenMessageScrollerOptions {
+    threshold?: number;
+    onStateChange?: (state: LumenMessageScrollState) => void;
+}
+export interface LumenMessageScrollerController {
+    destroy: () => void;
+    scrollToEnd: () => void;
+}
+/** Opt-in follow behavior. The application owns message identity and pagination. */
+export declare const createLumenMessageScrollerController: (viewport: HTMLElement, options?: LumenMessageScrollerOptions) => LumenMessageScrollerController;
+//# sourceMappingURL=message-scroller.d.ts.map

package/dist/message-scroller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-scroller.d.ts","sourceRoot":"","sources":["../src/message-scroller.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,uBAAuB;IAAG,KAAK,EAAE,OAAO,CAAA;CAAE;AAE3D,MAAM,WAAW,2BAA2B;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,IAAI,CAAA;CACzD;AAED,MAAM,WAAW,8BAA8B;IAC7C,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,WAAW,EAAE,MAAM,IAAI,CAAA;CACxB;AAED,oFAAoF;AACpF,eAAO,MAAM,oCAAoC,GAC/C,UAAU,WAAW,EAAE,UAAS,2BAAgC,KAC/D,8BA0JF,CAAA"}

package/dist/message-scroller.js

@@ -0,0 +1,113 @@
+/** Opt-in follow behavior. The application owns message identity and pagination. */
+export const createLumenMessageScrollerController = (viewport, options = {}) => {
+    const view = viewport.ownerDocument.defaultView;
+    if (!view)
+        throw new Error('MessageScroller requires a document with a window.');
+    const threshold = options.threshold ?? 32;
+    if (!Number.isFinite(threshold) || threshold < 0)
+        throw new RangeError('MessageScroller threshold must be a finite nonnegative distance.');
+    let atEnd = true;
+    let anchor;
+    let frame;
+    let destroyed = false;
+    let programmaticTop;
+    const jump = viewport.querySelector('[data-ui-message-jump]');
+    const previousAnchor = viewport.style.overflowAnchor;
+    const previousBehavior = viewport.style.scrollBehavior;
+    const previousTabIndex = viewport.getAttribute('tabindex');
+    viewport.style.overflowAnchor = 'none';
+    viewport.style.scrollBehavior = 'auto';
+    if (previousTabIndex === null)
+        viewport.tabIndex = 0;
+    const captureAnchor = () => {
+        const top = viewport.getBoundingClientRect().top;
+        const item = [...viewport.querySelectorAll('[data-ui-message-item]')].find(element => element.getBoundingClientRect().bottom > top);
+        anchor = item ? { element: item, top: item.getBoundingClientRect().top } : undefined;
+    };
+    const announce = () => {
+        viewport.dataset.atEnd = String(atEnd);
+        if (jump)
+            jump.hidden = atEnd;
+        options.onStateChange?.({ atEnd });
+        viewport.dispatchEvent(new view.CustomEvent('ui:message-scroll-state', { bubbles: true, detail: { atEnd } }));
+    };
+    const scrollToEnd = () => {
+        atEnd = true;
+        // Hiding the jump action changes the scroll extent; measure its final layout.
+        announce();
+        viewport.scrollTop = Math.max(0, viewport.scrollHeight - viewport.clientHeight);
+        programmaticTop = viewport.scrollTop;
+        captureAnchor();
+    };
+    const onScroll = () => {
+        if (viewport.scrollTop === programmaticTop) {
+            programmaticTop = undefined;
+            captureAnchor();
+            return;
+        }
+        programmaticTop = undefined;
+        const next = viewport.scrollHeight - viewport.clientHeight - viewport.scrollTop <= threshold;
+        if (next !== atEnd) {
+            atEnd = next;
+            announce();
+        }
+        captureAnchor();
+    };
+    const refresh = () => {
+        if (frame !== undefined || destroyed)
+            return;
+        frame = view.requestAnimationFrame(() => {
+            frame = undefined;
+            if (destroyed)
+                return;
+            if (atEnd)
+                scrollToEnd();
+            else {
+                if (anchor?.element.isConnected && viewport.contains(anchor.element)) {
+                    viewport.scrollTop += anchor.element.getBoundingClientRect().top - anchor.top;
+                }
+                captureAnchor();
+            }
+        });
+    };
+    const resize = typeof view.ResizeObserver === 'function' ? new view.ResizeObserver(refresh) : undefined;
+    const observeContent = () => {
+        resize?.disconnect();
+        resize?.observe(viewport);
+        for (const child of viewport.children)
+            resize?.observe(child);
+    };
+    const mutation = new view.MutationObserver(records => {
+        if (!records.some(record => record.type === 'childList' || record.type === 'characterData'))
+            return;
+        observeContent();
+        refresh();
+    });
+    mutation.observe(viewport, { childList: true, characterData: true, subtree: true });
+    observeContent();
+    viewport.addEventListener('scroll', onScroll, { passive: true });
+    const jumpToEnd = () => {
+        const focused = viewport.ownerDocument.activeElement === jump;
+        scrollToEnd();
+        if (focused)
+            viewport.focus({ preventScroll: true });
+    };
+    jump?.addEventListener('click', jumpToEnd);
+    scrollToEnd();
+    return {
+        scrollToEnd,
+        destroy: () => {
+            destroyed = true;
+            mutation.disconnect();
+            resize?.disconnect();
+            viewport.removeEventListener('scroll', onScroll);
+            jump?.removeEventListener('click', jumpToEnd);
+            viewport.style.overflowAnchor = previousAnchor;
+            viewport.style.scrollBehavior = previousBehavior;
+            if (previousTabIndex === null)
+                viewport.removeAttribute('tabindex');
+            if (frame !== undefined)
+                view.cancelAnimationFrame(frame);
+        }
+    };
+};

package/dist/motion-workflows.d.ts

@@ -0,0 +1,24 @@
+import { lumenDurations } from './foundations.generated.js';
+export type LumenWorkflowDuration = keyof typeof lumenDurations;
+export interface LumenMotionGroupOptions {
+    duration?: LumenWorkflowDuration;
+    enterExit?: boolean;
+}
+export interface LumenMotionGroupController {
+    destroy(): void;
+    refresh(): void;
+    update(change: () => void): void;
+}
+/** Resolve shared motion tokens without requiring a browser during import. */
+export declare const getLumenWorkflowTiming: (element: Element, duration?: LumenWorkflowDuration) => {
+    duration: number;
+    easing: string;
+};
+export declare const isLumenWorkflowMotionReduced: (element: Element) => boolean;
+/** Animate keyed direct children while leaving DOM ordering and focus with the application. */
+export declare const createLumenMotionGroupController: (root: HTMLElement, options?: LumenMotionGroupOptions) => LumenMotionGroupController;
+/** Observe application-owned child changes; animation ghosts never trigger another refresh. */
+export declare const bindLumenMotionGroup: (root: HTMLElement, options?: LumenMotionGroupOptions) => (() => void);
+/** Execute application updates exactly once, whether a view transition is available or not. */
+export declare const runLumenViewTransition: (ownerDocument: Document, update: () => void | Promise<void>) => Promise<void>;
+//# sourceMappingURL=motion-workflows.d.ts.map

package/dist/motion-workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion-workflows.d.ts","sourceRoot":"","sources":["../src/motion-workflows.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAgB,MAAM,4BAA4B,CAAA;AAEzE,MAAM,MAAM,qBAAqB,GAAG,MAAM,OAAO,cAAc,CAAA;AAE/D,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,qBAAqB,CAAA;IAChC,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,IAAI,IAAI,CAAA;IAEf,OAAO,IAAI,IAAI,CAAA;IAEf,MAAM,CAAC,MAAM,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;CACjC;AAiBD,8EAA8E;AAC9E,eAAO,MAAM,sBAAsB,GACjC,SAAS,OAAO,EAAE,WAAU,qBAAkC,KAC7D;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAUpC,CAAA;AAED,eAAO,MAAM,4BAA4B,GAAI,SAAS,OAAO,KAAG,OACoC,CAAA;AAgEpG,+FAA+F;AAC/F,eAAO,MAAM,gCAAgC,GAC3C,MAAM,WAAW,EAAE,UAAS,uBAA4B,KACvD,0BAkIF,CAAA;AAED,+FAA+F;AAC/F,eAAO,MAAM,oBAAoB,GAC/B,MAAM,WAAW,EAAE,UAAS,uBAA4B,KACvD,CAAC,MAAM,IAAI,CAqBb,CAAA;AAED,+FAA+F;AAC/F,eAAO,MAAM,sBAAsB,GACjC,eAAe,QAAQ,EAAE,QAAQ,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAC1D,OAAO,CAAC,IAAI,CAqCd,CAAA"}

package/dist/motion-workflows.js

@@ -0,0 +1,220 @@
+import { lumenDurations, lumenEasings } from './foundations.generated.js';
+const durationMilliseconds = (value) => {
+    const parsed = Number.parseFloat(value);
+    if (value.endsWith('ms'))
+        return parsed;
+    if (value.endsWith('s'))
+        return parsed * 1000;
+    return Number.NaN;
+};
+/** Resolve shared motion tokens without requiring a browser during import. */
+export const getLumenWorkflowTiming = (element, duration = 'standard') => {
+    const style = element.ownerDocument.defaultView?.getComputedStyle(element);
+    const token = duration === 'standard' ? '--ui-duration' : `--ui-duration-${duration}`;
+    const value = style?.getPropertyValue(token).trim() ?? '';
+    const milliseconds = durationMilliseconds(value);
+    return {
+        duration: Number.isFinite(milliseconds) && milliseconds >= 0 ? milliseconds : lumenDurations[duration],
+        easing: style?.getPropertyValue('--ui-ease').trim() || `cubic-bezier(${lumenEasings.standard.join(',')})`
+    };
+};
+export const isLumenWorkflowMotionReduced = (element) => Boolean(element.closest('[data-ui-motion="reduce"]')) ||
+    Boolean(element.ownerDocument.defaultView?.matchMedia('(prefers-reduced-motion: reduce)').matches);
+const snapshots = (root) => {
+    const result = new Map();
+    const duplicates = new Set();
+    for (const element of root.querySelectorAll(':scope > [data-ui-motion-key]')) {
+        const key = element.dataset.uiMotionKey;
+        if (!key || element.hidden || duplicates.has(key))
+            continue;
+        if (result.has(key)) {
+            result.delete(key);
+            duplicates.add(key);
+            continue;
+        }
+        result.set(key, { element, rect: element.getBoundingClientRect() });
+    }
+    return result;
+};
+const exitGhost = (root, snapshot) => {
+    const descendants = [snapshot.element, ...snapshot.element.querySelectorAll('*')];
+    if (descendants.some(element => element.localName.includes('-') || element.matches('iframe, object, embed, audio, video, canvas, script')))
+        return undefined;
+    const ghost = snapshot.element.cloneNode(true);
+    const view = root.ownerDocument.defaultView;
+    if (!view || !(ghost instanceof view.HTMLElement))
+        return undefined;
+    for (const element of [ghost, ...ghost.querySelectorAll('*')]) {
+        for (const name of ['id', 'name', 'autofocus', 'data-ui-motion-key'])
+            element.removeAttribute(name);
+    }
+    ghost.setAttribute('aria-hidden', 'true');
+    ghost.removeAttribute('hidden');
+    ghost.inert = true;
+    ghost.dataset.uiMotionGhost = '';
+    const frame = root.getBoundingClientRect();
+    Object.assign(ghost.style, {
+        height: `${snapshot.rect.height}px`,
+        left: `${snapshot.rect.left - frame.left + root.scrollLeft}px`,
+        margin: '0',
+        pointerEvents: 'none',
+        position: 'absolute',
+        top: `${snapshot.rect.top - frame.top + root.scrollTop}px`,
+        width: `${snapshot.rect.width}px`
+    });
+    root.append(ghost);
+    return ghost;
+};
+/** Animate keyed direct children while leaving DOM ordering and focus with the application. */
+export const createLumenMotionGroupController = (root, options = {}) => {
+    let previous = snapshots(root);
+    let destroyed = false;
+    const animations = new Map();
+    const preference = root.ownerDocument.defaultView?.matchMedia('(prefers-reduced-motion: reduce)');
+    const cancel = () => {
+        for (const [animation, cleanup] of animations) {
+            animation.cancel();
+            cleanup?.();
+        }
+        animations.clear();
+    };
+    const animate = (element, keyframes, cleanup) => {
+        if (typeof element.animate !== 'function') {
+            cleanup?.();
+            return;
+        }
+        try {
+            const animation = element.animate(keyframes, getLumenWorkflowTiming(root, options.duration));
+            animations.set(animation, cleanup);
+            const finish = () => {
+                if (!animations.has(animation))
+                    return;
+                animations.delete(animation);
+                cleanup?.();
+            };
+            void animation.finished.then(finish, finish);
+        }
+        catch {
+            cleanup?.();
+        }
+    };
+    const animateChildren = (current) => {
+        for (const [key, snapshot] of current) {
+            const old = previous.get(key);
+            if (old) {
+                const x = old.rect.left - snapshot.rect.left;
+                const y = old.rect.top - snapshot.rect.top;
+                if (x || y)
+                    animate(snapshot.element, [{ translate: `${x}px ${y}px` }, { translate: '0px 0px' }]);
+            }
+            else if (options.enterExit !== false) {
+                animate(snapshot.element, [{ opacity: 0, translate: '0px 8px' }, { opacity: 1, translate: '0px 0px' }]);
+            }
+        }
+    };
+    const animateExits = (current) => {
+        if (options.enterExit === false)
+            return;
+        for (const [key, snapshot] of previous) {
+            if (current.has(key))
+                continue;
+            const ghost = exitGhost(root, snapshot);
+            if (ghost)
+                animate(ghost, [{ opacity: 1 }, { opacity: 0 }], () => {
+                    ghost.remove();
+                });
+        }
+    };
+    const refresh = () => {
+        if (destroyed)
+            return;
+        const interrupted = animations.size > 0;
+        cancel();
+        const current = snapshots(root);
+        const canAnimate = !interrupted && !isLumenWorkflowMotionReduced(root);
+        if (canAnimate && getLumenWorkflowTiming(root, options.duration).duration > 0) {
+            animateChildren(current);
+            animateExits(current);
+        }
+        previous = current;
+    };
+    const reduce = () => {
+        if (preference?.matches)
+            cancel();
+    };
+    preference?.addEventListener('change', reduce);
+    return {
+        destroy: () => {
+            destroyed = true;
+            cancel();
+            preference?.removeEventListener('change', reduce);
+            previous.clear();
+        },
+        refresh,
+        update: change => {
+            if (destroyed) {
+                change();
+                return;
+            }
+            previous = snapshots(root);
+            const focused = root.ownerDocument.activeElement;
+            try {
+                change();
+            }
+            finally {
+                refresh();
+                const view = root.ownerDocument.defaultView;
+                if (view && focused instanceof view.HTMLElement && root.contains(focused) &&
+                    root.ownerDocument.activeElement === root.ownerDocument.body)
+                    focused.focus({ preventScroll: true });
+            }
+        }
+    };
+};
+/** Observe application-owned child changes; animation ghosts never trigger another refresh. */
+export const bindLumenMotionGroup = (root, options = {}) => {
+    const controller = createLumenMotionGroupController(root, options);
+    const view = root.ownerDocument.defaultView;
+    if (!view)
+        return () => {
+            controller.destroy();
+        };
+    const isGhost = (node) => node instanceof view.Element && node.hasAttribute('data-ui-motion-ghost');
+    const observer = new view.MutationObserver(records => {
+        if (records.some(record => record.type === 'attributes' || [...record.addedNodes, ...record.removedNodes].some(node => !isGhost(node))))
+            controller.refresh();
+    });
+    observer.observe(root, { attributeFilter: ['hidden', 'data-ui-motion-key'], attributes: true, childList: true, subtree: true });
+    return () => {
+        observer.disconnect();
+        controller.destroy();
+    };
+};
+/** Execute application updates exactly once, whether a view transition is available or not. */
+export const runLumenViewTransition = async (ownerDocument, update) => {
+    const view = ownerDocument.defaultView;
+    if (typeof ownerDocument.startViewTransition !== 'function' ||
+        view?.matchMedia('(prefers-reduced-motion: reduce)').matches ||
+        ownerDocument.documentElement.dataset.uiMotion === 'reduce') {
+        await update();
+        return;
+    }
+    let pendingUpdate;
+    const once = () => {
+        pendingUpdate ??= Promise.resolve().then(update);
+        return pendingUpdate;
+    };
+    let transition;
+    try {
+        transition = ownerDocument.startViewTransition(once);
+    }
+    catch {
+        await once();
+        return;
+    }
+    // Rendering/animation failures must not suppress a successful application update.
+    void transition.ready.catch(() => undefined);
+    void transition.finished.catch(() => undefined);
+    await transition.updateCallbackDone;
+    await transition.finished.catch(() => undefined);
+};

package/dist/motion.d.ts

@@ -0,0 +1,12 @@
+export type LumenMotionPreset = 'fade' | 'slide-up' | 'scale';
+export type LumenMotionDuration = 'fast' | 'standard' | 'slow';
+export type LumenMotionResult = 'finished' | 'cancelled' | 'skipped';
+export interface LumenPresenceOptions {
+    duration?: LumenMotionDuration;
+    phase?: 'enter' | 'exit';
+    preset?: LumenMotionPreset;
+    signal?: AbortSignal;
+}
+/** Animate presentation only; consumers retain DOM, focus, and framework state ownership. */
+export declare const animateLumenPresence: (element: HTMLElement, options?: LumenPresenceOptions) => Promise<LumenMotionResult>;
+//# sourceMappingURL=motion.d.ts.map

package/dist/motion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion.d.ts","sourceRoot":"","sources":["../src/motion.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,UAAU,GAAG,OAAO,CAAA;AAC7D,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,UAAU,GAAG,MAAM,CAAA;AAC9D,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,WAAW,GAAG,SAAS,CAAA;AAEpE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,mBAAmB,CAAA;IAC9B,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;IACxB,MAAM,CAAC,EAAE,iBAAiB,CAAA;IAC1B,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAiGD,6FAA6F;AAC7F,eAAO,MAAM,oBAAoB,GAC/B,SAAS,WAAW,EAAE,UAAS,oBAAyB,KACvD,OAAO,CAAC,iBAAiB,CAqB3B,CAAA"}

package/dist/motion.js

@@ -0,0 +1,96 @@
+import { lumenDurations, lumenMotion } from './tokens.js';
+const activeAnimations = new WeakMap();
+const readDuration = (style, duration) => {
+    const token = duration === 'standard' ? '--ui-duration' : `--ui-duration-${duration}`;
+    const match = /^(\d+(?:\.\d+)?|\.\d+)(ms|s)$/.exec(style.getPropertyValue(token).trim());
+    if (!match)
+        return lumenDurations[duration];
+    const value = Number(match[1]) * (match[2] === 's' ? 1000 : 1);
+    return Number.isFinite(value) ? value : lumenDurations[duration];
+};
+const presenceFrames = (style, preset) => {
+    const transform = style.transform || 'none';
+    const baseTransform = transform === 'none' ? '' : `${transform} `;
+    let offsetTransform = transform;
+    if (preset === 'scale')
+        offsetTransform = `${baseTransform}scale(0.96)`;
+    if (preset === 'slide-up')
+        offsetTransform = `${baseTransform}translateY(0.75rem)`;
+    return [
+        { opacity: '0', transform: offsetTransform },
+        { opacity: style.opacity || '1', transform }
+    ];
+};
+const settleAnimation = async (animation, preference, signal) => {
+    const state = { reduced: false };
+    const cancel = () => {
+        animation.cancel();
+    };
+    const onPreferenceChange = (event) => {
+        if (!event.matches)
+            return;
+        state.reduced = true;
+        cancel();
+    };
+    signal?.addEventListener('abort', cancel, { once: true });
+    preference.addEventListener('change', onPreferenceChange);
+    if (signal?.aborted)
+        cancel();
+    try {
+        await animation.finished;
+        return 'finished';
+    }
+    catch (error) {
+        if (animation.playState === 'idle')
+            return state.reduced ? 'skipped' : 'cancelled';
+        throw error;
+    }
+    finally {
+        signal?.removeEventListener('abort', cancel);
+        preference.removeEventListener('change', onPreferenceChange);
+    }
+};
+const motionContext = (element) => {
+    const view = element.ownerDocument.defaultView;
+    if (!view || !element.isConnected || typeof element.animate !== 'function')
+        return undefined;
+    if (typeof view.matchMedia !== 'function')
+        return undefined;
+    const preference = view.matchMedia('(prefers-reduced-motion: reduce)');
+    if (preference.matches || element.closest('[data-ui-motion="reduce"]'))
+        return undefined;
+    return { preference, style: view.getComputedStyle(element) };
+};
+const startPresence = (element, style, options) => {
+    const duration = readDuration(style, options.duration ?? 'standard');
+    if (duration === 0)
+        return undefined;
+    const frames = presenceFrames(style, options.preset ?? 'fade');
+    if (options.phase === 'exit')
+        frames.reverse();
+    return element.animate(frames, {
+        duration,
+        easing: style.getPropertyValue('--ui-ease-emphasized').trim() || lumenMotion.easeEmphasized
+    });
+};
+/** Animate presentation only; consumers retain DOM, focus, and framework state ownership. */
+export const animateLumenPresence = async (element, options = {}) => {
+    // An aborted request must not cancel another caller's active animation.
+    if (options.signal?.aborted)
+        return 'cancelled';
+    activeAnimations.get(element)?.cancel();
+    const context = motionContext(element);
+    if (!context)
+        return 'skipped';
+    const animation = startPresence(element, context.style, options);
+    if (!animation)
+        return 'skipped';
+    activeAnimations.set(element, animation);
+    try {
+        return await settleAnimation(animation, context.preference, options.signal);
+    }
+    finally {
+        if (activeAnimations.get(element) === animation)
+            activeAnimations.delete(element);
+    }
+};

package/dist/native-input.d.ts

@@ -0,0 +1,25 @@
+/** Bounded, ungrouped decimal drafts. Arithmetic never passes through a floating-point number. */
+export type LumenDecimalDraft = {
+    kind: 'empty' | 'incomplete' | 'invalid';
+} | {
+    coefficient: bigint;
+    kind: 'valid';
+    scale: number;
+};
+export interface LumenDecimalOptions {
+    locale?: string;
+    max?: string;
+    min?: string;
+    step?: string;
+}
+export declare const parseLumenDecimalDraft: (value: string, locale?: string) => LumenDecimalDraft;
+export declare const isLumenDecimalInBounds: (value: string, options?: LumenDecimalOptions) => boolean;
+export declare const stepLumenDecimalDraft: (value: string, direction: -1 | 1, options?: LumenDecimalOptions) => string | null;
+export declare const normalizeLumenNumericOTP: (proposal: string, length?: number) => string | null;
+export interface LumenTimeSelection {
+    hour: number;
+    minute: number;
+}
+export declare const isLumenTimeSelection: (value: unknown) => value is LumenTimeSelection;
+export declare const isLumenTimeInBounds: (value: unknown, min?: LumenTimeSelection, max?: LumenTimeSelection) => boolean;
+//# sourceMappingURL=native-input.d.ts.map

package/dist/native-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-input.d.ts","sourceRoot":"","sources":["../src/native-input.ts"],"names":[],"mappings":"AAAA,kGAAkG;AAClG,MAAM,MAAM,iBAAiB,GACzB;IAAE,IAAI,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CAAA;CAAE,GAC9C;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEvD,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAyDD,eAAO,MAAM,sBAAsB,GAAI,OAAO,MAAM,EAAE,SAAS,MAAM,KAAG,iBAgBvE,CAAA;AAuCD,eAAO,MAAM,sBAAsB,GAAI,OAAO,MAAM,EAAE,UAAS,mBAAwB,KAAG,OAOzF,CAAA;AAsCD,eAAO,MAAM,qBAAqB,GAChC,OAAO,MAAM,EACb,WAAW,CAAC,CAAC,GAAG,CAAC,EACjB,UAAS,mBAAwB,KAChC,MAAM,GAAG,IAuBX,CAAA;AASD,eAAO,MAAM,wBAAwB,GAAI,UAAU,MAAM,EAAE,eAAU,KAAG,MAAM,GAAG,IAiBhF,CAAA;AAED,MAAM,WAAW,kBAAkB;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AAMpE,eAAO,MAAM,oBAAoB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,kBAG9D,CAAA;AAcD,eAAO,MAAM,mBAAmB,GAC9B,OAAO,OAAO,EACd,MAAM,kBAAkB,EACxB,MAAM,kBAAkB,KACvB,OAMF,CAAA"}