@santi020k/lumen-core 3.0.1 → 4.1.0

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"}

package/dist/native-input.js

@@ -0,0 +1,188 @@
+const decimalFormatter = (locale) => {
+    try {
+        return new Intl.NumberFormat(locale, { useGrouping: false });
+    }
+    catch {
+        return new Intl.NumberFormat('en', { useGrouping: false });
+    }
+};
+const decimalSymbols = (locale) => {
+    const formatter = decimalFormatter(locale);
+    const parts = formatter.formatToParts(-1.1);
+    return {
+        decimal: parts.find(part => part.type === 'decimal')?.value ?? '.',
+        digits: Array.from({ length: 10 }, (_, digit) => formatter.format(digit)),
+        minus: parts.find(part => part.type === 'minusSign')?.value ?? '-'
+    };
+};
+const numericDigit = (character) => {
+    if (!/^\p{Decimal_Number}$/u.test(character))
+        return null;
+    const code = character.codePointAt(0);
+    if (code === undefined)
+        return null;
+    let start = code;
+    while (/^\p{Decimal_Number}$/u.test(String.fromCodePoint(start - 1)))
+        start -= 1;
+    return (code - start) % 10;
+};
+const scanDecimalDigits = (value, separator, localizedDigits) => {
+    let digits = '';
+    let decimalSeen = false;
+    let scale = 0;
+    for (const character of value) {
+        const localizedDigit = localizedDigits.indexOf(character);
+        const digit = localizedDigit < 0 ? numericDigit(character) : localizedDigit;
+        if (digit !== null) {
+            digits += String(digit);
+            if (decimalSeen)
+                scale += 1;
+        }
+        else if (character === separator && !decimalSeen)
+            decimalSeen = true;
+        else
+            return null;
+    }
+    return { digits, scale };
+};
+export const parseLumenDecimalDraft = (value, locale) => {
+    if (value === '')
+        return { kind: 'empty' };
+    if (value.length > 128)
+        return { kind: 'invalid' };
+    const symbols = decimalSymbols(locale);
+    const negative = value.startsWith(symbols.minus) || value.startsWith('-');
+    const signLength = value.startsWith(symbols.minus) ? symbols.minus.length : 1;
+    const unsigned = negative ? value.slice(signLength) : value;
+    const scanned = scanDecimalDigits(unsigned, symbols.decimal, symbols.digits);
+    if (!scanned)
+        return { kind: 'invalid' };
+    if (scanned.digits === '' || unsigned.endsWith(symbols.decimal))
+        return { kind: 'incomplete' };
+    return { coefficient: BigInt(scanned.digits) * (negative ? -1n : 1n), kind: 'valid', scale: scanned.scale };
+};
+const parseConfiguration = (value) => {
+    if (value === undefined)
+        return undefined;
+    for (const character of value) {
+        if (!'0123456789.-'.includes(character))
+            throw new RangeError('Decimal configuration must use ASCII digits.');
+    }
+    const parsed = parseLumenDecimalDraft(value, 'en-US');
+    if (parsed.kind !== 'valid')
+        throw new RangeError('Decimal configuration must be a complete ungrouped decimal of at most 128 characters.');
+    return parsed;
+};
+const compareDecimals = (left, right) => {
+    const scale = Math.max(left.scale, right.scale);
+    const difference = left.coefficient * 10n ** BigInt(scale - left.scale) -
+        right.coefficient * 10n ** BigInt(scale - right.scale);
+    return difference < 0n ? -1 : Number(difference > 0n);
+};
+const decimalConfiguration = (options) => {
+    const min = parseConfiguration(options.min);
+    const max = parseConfiguration(options.max);
+    const step = parseConfiguration(options.step ?? '1');
+    if (!step || step.coefficient <= 0n)
+        throw new RangeError('Decimal step must be positive.');
+    if (min && max && compareDecimals(min, max) > 0)
+        throw new RangeError('Decimal minimum must not exceed maximum.');
+    return { max, min, step };
+};
+export const isLumenDecimalInBounds = (value, options = {}) => {
+    const { max, min } = decimalConfiguration(options);
+    const draft = parseLumenDecimalDraft(value, options.locale);
+    return draft.kind === 'valid' &&
+        (!min || compareDecimals(draft, min) >= 0) &&
+        (!max || compareDecimals(draft, max) <= 0);
+};
+const localizeDigits = (value, digits) => {
+    let result = '';
+    for (const digit of value)
+        result += digits[Number(digit)] ?? digit;
+    return result;
+};
+const startingDecimal = (draft, min, max) => {
+    if (draft.kind === 'valid')
+        return draft;
+    if (draft.kind !== 'empty')
+        return null;
+    if (min)
+        return min;
+    if (max && max.coefficient < 0n)
+        return max;
+    return { coefficient: 0n, kind: 'valid', scale: 0 };
+};
+const formatDecimal = (value, locale) => {
+    const symbols = decimalSymbols(locale);
+    const negative = value.coefficient < 0n;
+    const absolute = negative ? -value.coefficient : value.coefficient;
+    const digits = absolute.toString().padStart(value.scale + 1, '0');
+    let fraction = value.scale > 0 ? digits.slice(-value.scale) : '';
+    while (fraction.endsWith('0'))
+        fraction = fraction.slice(0, -1);
+    const integer = value.scale > 0 ? digits.slice(0, -value.scale) : digits;
+    const localized = localizeDigits(integer, symbols.digits);
+    const localizedFraction = localizeDigits(fraction, symbols.digits);
+    return `${negative ? symbols.minus : ''}${localized}${fraction ? symbols.decimal + localizedFraction : ''}`;
+};
+export const stepLumenDecimalDraft = (value, direction, options = {}) => {
+    const { max, min, step } = decimalConfiguration(options);
+    const draft = parseLumenDecimalDraft(value, options.locale);
+    const start = startingDecimal(draft, min, max);
+    if (!start)
+        return null;
+    const scale = Math.max(start.scale, step.scale);
+    let result = {
+        coefficient: start.coefficient * 10n ** BigInt(scale - start.scale) +
+            BigInt(direction) * step.coefficient * 10n ** BigInt(scale - step.scale),
+        kind: 'valid',
+        scale
+    };
+    if (min && compareDecimals(result, min) < 0)
+        result = min;
+    if (max && compareDecimals(result, max) > 0)
+        result = max;
+    const formatted = formatDecimal(result, options.locale);
+    return formatted.length <= 128 ? formatted : null;
+};
+/** Single-editor numeric OTP normalization; separators are accepted, unrelated text is rejected. */
+const validateOTPLength = (length) => {
+    if (!Number.isInteger(length) || length < 1 || length > 12) {
+        throw new RangeError('OTP length must be between 1 and 12.');
+    }
+};
+export const normalizeLumenNumericOTP = (proposal, length = 6) => {
+    validateOTPLength(length);
+    if (proposal.length > 128)
+        return null;
+    let result = '';
+    for (const character of proposal) {
+        const digit = numericDigit(character);
+        if (digit !== null)
+            result += String(digit);
+        else if (character !== '-' && character.trim() !== '')
+            return null;
+        if (result.length > length)
+            return null;
+    }
+    return result;
+};
+const isTimePart = (value, limit) => (typeof value === 'number' && Number.isInteger(value) && value >= 0 && value < limit);
+export const isLumenTimeSelection = (value) => (typeof value === 'object' && value !== null && !Array.isArray(value) &&
+    'hour' in value && 'minute' in value && isTimePart(value.hour, 24) && isTimePart(value.minute, 60));
+const timeMinutes = (time) => time.hour * 60 + time.minute;
+const validateTimeBounds = (min, max) => {
+    if ((min && !isLumenTimeSelection(min)) || (max && !isLumenTimeSelection(max))) {
+        throw new RangeError('Time bounds must contain valid wall-clock values.');
+    }
+    if (min && max && timeMinutes(min) > timeMinutes(max)) {
+        throw new RangeError('Time bounds must be ordered within one day.');
+    }
+};
+export const isLumenTimeInBounds = (value, min, max) => {
+    validateTimeBounds(min, max);
+    return isLumenTimeSelection(value) &&
+        (!min || timeMinutes(value) >= timeMinutes(min)) &&
+        (!max || timeMinutes(value) <= timeMinutes(max));
+};

package/dist/phone-flags.generated.d.ts

@@ -0,0 +1,2 @@
+export declare const lumenPhoneFlagSources: Readonly<Record<string, string>>;
+//# sourceMappingURL=phone-flags.generated.d.ts.map

package/dist/phone-flags.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phone-flags.generated.d.ts","sourceRoot":"","sources":["../src/phone-flags.generated.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAoQlE,CAAA"}