@atmos.build/ui 0.1.0

package/dist/lib/local-ui-state.js

@@ -0,0 +1,95 @@
+'use client';
+import { useCallback, useSyncExternalStore } from 'react';
+/**
+ * Parsed values are held here because useSyncExternalStore compares snapshots by identity:
+ * re-parsing localStorage on every read would hand it a new object each render.
+ */
+const snapshots = new Map();
+const subscribers = new Map();
+let crossTabSyncStarted = false;
+function localUiStorage() {
+    try {
+        return typeof window === 'undefined' ? null : window.localStorage;
+    }
+    catch {
+        return null;
+    }
+}
+function notify(key) {
+    for (const subscriber of subscribers.get(key) ?? [])
+        subscriber();
+}
+function startCrossTabSync() {
+    if (crossTabSyncStarted || typeof window === 'undefined')
+        return;
+    crossTabSyncStarted = true;
+    window.addEventListener('storage', (event) => {
+        if (!event.key || !subscribers.has(event.key))
+            return;
+        snapshots.delete(event.key);
+        notify(event.key);
+    });
+}
+export function readLocalUiState(key, fallback) {
+    if (snapshots.has(key))
+        return snapshots.get(key);
+    const raw = localUiStorage()?.getItem(key);
+    let value = fallback;
+    if (raw != null) {
+        try {
+            value = JSON.parse(raw);
+        }
+        catch {
+            value = fallback;
+        }
+    }
+    snapshots.set(key, value);
+    return value;
+}
+export function writeLocalUiState(key, value) {
+    if (snapshots.has(key) && Object.is(snapshots.get(key), value))
+        return;
+    snapshots.set(key, value);
+    try {
+        localUiStorage()?.setItem(key, JSON.stringify(value));
+    }
+    catch {
+        void 0;
+    }
+    notify(key);
+}
+export function subscribeLocalUiState(key, onChange) {
+    startCrossTabSync();
+    const forKey = subscribers.get(key) ?? new Set();
+    subscribers.set(key, forKey);
+    forKey.add(onChange);
+    return () => {
+        forKey.delete(onChange);
+        if (forKey.size === 0)
+            subscribers.delete(key);
+    };
+}
+/** Drops every value this facility holds, so one test's layout cannot reach the next. */
+export function clearLocalUiState() {
+    const keys = [...snapshots.keys()];
+    snapshots.clear();
+    const storage = localUiStorage();
+    for (const key of keys) {
+        try {
+            storage?.removeItem(key);
+        }
+        catch {
+            void 0;
+        }
+        notify(key);
+    }
+}
+/**
+ * A piece of this browser's own view of the app — a width, a collapsed section, a chosen
+ * tab. Everything a teammate should see instead belongs in a shape, not here.
+ */
+export function useLocalUiState(key, fallback) {
+    const value = useSyncExternalStore(useCallback((onChange) => subscribeLocalUiState(key, onChange), [key]), () => readLocalUiState(key, fallback), () => fallback);
+    const setValue = useCallback((next) => writeLocalUiState(key, next), [key]);
+    return [value, setValue];
+}

package/dist/lib/parse-loose-datetime.d.ts

@@ -0,0 +1 @@
+export declare function parseLooseDateTime(input: string, now?: Date): Date | null;

package/dist/lib/parse-loose-datetime.js

@@ -0,0 +1,180 @@
+import { parseLooseDate } from './parse-loose.js';
+const DAY_PARTS = {
+    morning: [9, 0],
+    noon: [12, 0],
+    midday: [12, 0],
+    afternoon: [15, 0],
+    evening: [18, 0],
+    night: [20, 0],
+    midnight: [0, 0],
+};
+const DEFAULT_HOUR = 9;
+const DEFAULT_MINUTE = 0;
+const MS = {
+    second: 1000,
+    minute: 60 * 1000,
+    hour: 60 * 60 * 1000,
+    day: 24 * 60 * 60 * 1000,
+    week: 7 * 24 * 60 * 60 * 1000,
+};
+function unitOf(token) {
+    if (!token)
+        return null;
+    if (/^(seconds?|secs?|s)$/.test(token))
+        return 'second';
+    if (/^(minutes?|mins?|m)$/.test(token))
+        return 'minute';
+    if (/^(hours?|hrs?|h)$/.test(token))
+        return 'hour';
+    if (/^(days?|d)$/.test(token))
+        return 'day';
+    if (/^(weeks?|w)$/.test(token))
+        return 'week';
+    return null;
+}
+function parseDuration(input, now) {
+    const s = input
+        .replace(/^in\s+/, '')
+        .replace(/\bhalf\s+(?:an?\s+)?hour\b/g, '30 minutes')
+        .replace(/\b(?:an?)\s+(?=(seconds?|secs?|minutes?|mins?|hours?|hrs?|days?|weeks?)\b)/g, '1 ')
+        .trim();
+    if (!s)
+        return null;
+    const re = /(\d+)\s*(seconds?|secs?|minutes?|mins?|hours?|hrs?|days?|weeks?|h|m|s|d|w)\b/g;
+    let totalMs = 0;
+    let matched = 0;
+    let m;
+    while ((m = re.exec(s)) !== null) {
+        const unit = unitOf(m[2]);
+        if (!unit)
+            return null;
+        totalMs += Number(m[1]) * MS[unit];
+        matched++;
+    }
+    if (matched === 0)
+        return null;
+    const leftover = s.replace(re, '').replace(/\b(and)\b/g, '').replace(/[,\s]+/g, '');
+    if (leftover)
+        return null;
+    return new Date(now.getTime() + totalMs);
+}
+function extractTime(input) {
+    const word = /\b(noon|midday|midnight)\b/.exec(input);
+    const wordPart = word?.[1] ? DAY_PARTS[word[1]] : undefined;
+    if (word && wordPart) {
+        return { hour: wordPart[0], minute: wordPart[1], rest: cut(input, word.index, word[0].length) };
+    }
+    const re = /\bat\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\b|\b(\d{1,2}):(\d{2})\s*(am|pm)?\b|\b(\d{1,2})\s*(am|pm)\b/gi;
+    let m;
+    while ((m = re.exec(input)) !== null) {
+        let hour;
+        let minute = 0;
+        let meridiem;
+        if (m[1] !== undefined) {
+            hour = Number(m[1]);
+            minute = m[2] !== undefined ? Number(m[2]) : 0;
+            meridiem = m[3];
+        }
+        else if (m[4] !== undefined) {
+            hour = Number(m[4]);
+            minute = Number(m[5]);
+            meridiem = m[6];
+        }
+        else {
+            hour = Number(m[7]);
+            meridiem = m[8];
+        }
+        if (minute > 59)
+            continue;
+        if (meridiem) {
+            if (hour < 1 || hour > 12)
+                continue;
+            const pm = meridiem.toLowerCase() === 'pm';
+            if (hour === 12)
+                hour = pm ? 12 : 0;
+            else if (pm)
+                hour += 12;
+        }
+        else if (hour > 23) {
+            continue;
+        }
+        return { hour, minute, rest: cut(input, m.index, m[0].length) };
+    }
+    return null;
+}
+function cut(s, start, len) {
+    return (s.slice(0, start) + s.slice(start + len)).replace(/\s+/g, ' ').trim();
+}
+function extractDayPart(input) {
+    const re = /\b(morning|afternoon|evening|night|midday|noon|midnight)\b/;
+    const m = re.exec(input);
+    const part = m?.[1] ? DAY_PARTS[m[1]] : undefined;
+    if (!m || !part)
+        return null;
+    const rest = cut(input, m.index, m[0].length).replace(/^this\b\s*/, '').trim();
+    return { hour: part[0], minute: part[1], rest };
+}
+function atTime(day, hour, minute) {
+    return new Date(day.getFullYear(), day.getMonth(), day.getDate(), hour, minute, 0, 0);
+}
+function resolveDatePhrase(phrase, now) {
+    const direct = parseLooseDate(phrase, now);
+    if (direct)
+        return direct;
+    const normalized = phrase
+        .replace(/,/g, ' ')
+        .replace(/(\d)\.(?=\s|$)/g, '$1')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (normalized !== phrase) {
+        const viaNormalized = parseLooseDate(normalized, now);
+        if (viaNormalized)
+            return viaNormalized;
+    }
+    const tokens = normalized.split(' ');
+    if (tokens.length >= 2 && /^[\p{L}]{2,12}\.?$/u.test(tokens[0] ?? '')) {
+        return parseLooseDate(tokens.slice(1).join(' '), now);
+    }
+    return null;
+}
+export function parseLooseDateTime(input, now = new Date()) {
+    const trimmed = input.trim().toLowerCase();
+    if (!trimmed)
+        return null;
+    const dur = parseDuration(trimmed, now);
+    if (dur)
+        return dur;
+    const normalized = trimmed.replace(/\btonight\b/g, 'today night');
+    const time = extractTime(normalized);
+    const afterTime = time ? time.rest : normalized;
+    const part = extractDayPart(afterTime);
+    const datePhrase = (part ? part.rest : afterTime).trim();
+    const day = datePhrase ? resolveDatePhrase(datePhrase, now) : new Date(now);
+    if (!day)
+        return null;
+    let hour;
+    let minute;
+    let hadTimeSignal = false;
+    if (time) {
+        hour = time.hour;
+        minute = time.minute;
+        hadTimeSignal = true;
+    }
+    else if (part) {
+        hour = part.hour;
+        minute = part.minute;
+        hadTimeSignal = true;
+    }
+    else if (datePhrase) {
+        hour = DEFAULT_HOUR;
+        minute = DEFAULT_MINUTE;
+    }
+    else {
+        return null;
+    }
+    const result = atTime(day, hour, minute);
+    if (hadTimeSignal && !datePhrase && result.getTime() <= now.getTime()) {
+        return atTime(new Date(now.getTime() + MS.day), hour, minute);
+    }
+    return result;
+}

package/dist/lib/parse-loose-time.d.ts

@@ -0,0 +1,6 @@
+export interface ParsedTime {
+    hour: number;
+    minute: number;
+}
+export declare function parseLooseTime(input: string): ParsedTime | null;
+export declare function parseLooseTimeMinutes(input: string): number | null;

package/dist/lib/parse-loose-time.js

@@ -0,0 +1,53 @@
+export function parseLooseTime(input) {
+    const s = input.trim().toLowerCase();
+    if (!s)
+        return null;
+    if (s === 'noon' || s === 'midday')
+        return { hour: 12, minute: 0 };
+    if (s === 'midnight')
+        return { hour: 0, minute: 0 };
+    let hour;
+    let minute;
+    let meridiem;
+    const colon = /^(\d{1,2})[:.](\d{2})\s*(am|pm)?$/.exec(s);
+    const bare = /^(\d{1,2})\s*(am|pm)?$/.exec(s);
+    const compact = /^(\d{3,4})\s*(am|pm)?$/.exec(s);
+    if (colon && colon[1] && colon[2]) {
+        hour = Number(colon[1]);
+        minute = Number(colon[2]);
+        meridiem = colon[3];
+    }
+    else if (compact && compact[1]) {
+        const digits = compact[1];
+        hour = Number(digits.slice(0, digits.length - 2));
+        minute = Number(digits.slice(-2));
+        meridiem = compact[2];
+    }
+    else if (bare && bare[1]) {
+        hour = Number(bare[1]);
+        minute = 0;
+        meridiem = bare[2];
+    }
+    else {
+        return null;
+    }
+    if (Number.isNaN(hour) || Number.isNaN(minute) || minute > 59)
+        return null;
+    if (meridiem) {
+        if (hour < 1 || hour > 12)
+            return null;
+        const pm = meridiem === 'pm';
+        if (hour === 12)
+            hour = pm ? 12 : 0;
+        else if (pm)
+            hour += 12;
+    }
+    else if (hour > 23) {
+        return null;
+    }
+    return { hour, minute };
+}
+export function parseLooseTimeMinutes(input) {
+    const parsed = parseLooseTime(input);
+    return parsed ? parsed.hour * 60 + parsed.minute : null;
+}

package/dist/lib/parse-loose.d.ts

@@ -0,0 +1 @@
+export declare function parseLooseDate(input: string, today?: Date): Date | null;

package/dist/lib/parse-loose.js

@@ -0,0 +1,170 @@
+const WEEKDAYS = {
+    sun: 0,
+    sunday: 0,
+    mon: 1,
+    monday: 1,
+    tue: 2,
+    tues: 2,
+    tuesday: 2,
+    wed: 3,
+    weds: 3,
+    wednesday: 3,
+    thu: 4,
+    thur: 4,
+    thurs: 4,
+    thursday: 4,
+    fri: 5,
+    friday: 5,
+    sat: 6,
+    saturday: 6,
+};
+const MONTHS = {
+    jan: 0,
+    january: 0,
+    januar: 0,
+    feb: 1,
+    february: 1,
+    februar: 1,
+    mar: 2,
+    march: 2,
+    märz: 2,
+    maerz: 2,
+    mrz: 2,
+    apr: 3,
+    april: 3,
+    may: 4,
+    mai: 4,
+    jun: 5,
+    june: 5,
+    juni: 5,
+    jul: 6,
+    july: 6,
+    juli: 6,
+    aug: 7,
+    august: 7,
+    sep: 8,
+    sept: 8,
+    september: 8,
+    oct: 9,
+    october: 9,
+    okt: 9,
+    oktober: 9,
+    nov: 10,
+    november: 10,
+    dec: 11,
+    december: 11,
+    dez: 11,
+    dezember: 11,
+};
+function startOfDay(d) {
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate());
+}
+function addDays(d, n) {
+    const out = startOfDay(d);
+    out.setDate(out.getDate() + n);
+    return out;
+}
+function addWeeks(d, n) {
+    return addDays(d, n * 7);
+}
+function addMonths(d, n) {
+    const out = startOfDay(d);
+    out.setMonth(out.getMonth() + n);
+    return out;
+}
+function daysUntilWeekday(today, target) {
+    const cur = today.getDay();
+    const delta = (target - cur + 7) % 7;
+    return delta === 0 ? 7 : delta;
+}
+function makeDate(y, m, d) {
+    if (m < 0 || m > 11)
+        return null;
+    if (d < 1 || d > 31)
+        return null;
+    const out = new Date(y, m, d);
+    if (out.getFullYear() !== y || out.getMonth() !== m || out.getDate() !== d)
+        return null;
+    return out;
+}
+function expandYear(yy) {
+    if (yy >= 100)
+        return yy;
+    return yy < 70 ? 2000 + yy : 1900 + yy;
+}
+export function parseLooseDate(input, today = new Date()) {
+    const trimmed = input.trim().toLowerCase();
+    if (!trimmed)
+        return null;
+    const t = startOfDay(today);
+    if (trimmed === 'today' || trimmed === 'now')
+        return t;
+    if (trimmed === 'tomorrow' || trimmed === 'tom')
+        return addDays(t, 1);
+    if (trimmed === 'yesterday')
+        return addDays(t, -1);
+    const next = /^next\s+(.+)$/.exec(trimmed);
+    if (next && next[1]) {
+        const what = next[1];
+        if (what === 'week')
+            return addWeeks(t, 1);
+        if (what === 'month')
+            return addMonths(t, 1);
+        const dow = WEEKDAYS[what];
+        if (dow !== undefined)
+            return addDays(t, daysUntilWeekday(t, dow));
+        return null;
+    }
+    const bareDow = WEEKDAYS[trimmed];
+    if (bareDow !== undefined) {
+        return addDays(t, daysUntilWeekday(t, bareDow));
+    }
+    const inN = /^in\s+(\d+)\s+(day|days|week|weeks|month|months)$/.exec(trimmed);
+    if (inN && inN[1] && inN[2]) {
+        const n = Number(inN[1]);
+        const unit = inN[2];
+        if (unit.startsWith('day'))
+            return addDays(t, n);
+        if (unit.startsWith('week'))
+            return addWeeks(t, n);
+        if (unit.startsWith('month'))
+            return addMonths(t, n);
+    }
+    const iso = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(trimmed);
+    if (iso && iso[1] && iso[2] && iso[3]) {
+        return makeDate(+iso[1], +iso[2] - 1, +iso[3]);
+    }
+    const slash = /^(\d{1,2})\/(\d{1,2})(?:\/(\d{2,4}))?$/.exec(trimmed);
+    if (slash && slash[1] && slash[2]) {
+        const m = +slash[1] - 1;
+        const d = +slash[2];
+        const y = slash[3] ? expandYear(+slash[3]) : t.getFullYear();
+        return makeDate(y, m, d);
+    }
+    const dot = /^(\d{1,2})\.(\d{1,2})(?:\.(\d{2,4}))?$/.exec(trimmed);
+    if (dot && dot[1] && dot[2]) {
+        const d = +dot[1];
+        const m = +dot[2] - 1;
+        const y = dot[3] ? expandYear(+dot[3]) : t.getFullYear();
+        return makeDate(y, m, d);
+    }
+    const monthFirst = /^([a-z]+)\s+(\d{1,2})(?:[,\s]+(\d{2,4}))?$/.exec(trimmed);
+    if (monthFirst && monthFirst[1] && monthFirst[2]) {
+        const m = MONTHS[monthFirst[1]];
+        if (m !== undefined) {
+            const d = +monthFirst[2];
+            const y = monthFirst[3] ? expandYear(+monthFirst[3]) : t.getFullYear();
+            return makeDate(y, m, d);
+        }
+    }
+    const dayFirst = /^(\d{1,2})\s+([a-z]+)(?:[,\s]+(\d{2,4}))?$/.exec(trimmed);
+    if (dayFirst && dayFirst[1] && dayFirst[2]) {
+        const m = MONTHS[dayFirst[2]];
+        if (m !== undefined) {
+            const d = +dayFirst[1];
+            const y = dayFirst[3] ? expandYear(+dayFirst[3]) : t.getFullYear();
+            return makeDate(y, m, d);
+        }
+    }
+    return null;
+}

package/dist/lib/react-19-jsx.d.ts

@@ -0,0 +1,8 @@
+import type { JSX as ReactJSX } from 'react';
+declare global {
+    namespace JSX {
+        type Element = ReactJSX.Element;
+        type IntrinsicElements = ReactJSX.IntrinsicElements;
+    }
+}
+export {};

package/dist/lib/react-19-jsx.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/view-chrome.d.ts

@@ -0,0 +1,5 @@
+export declare const viewControlClass = "h-7 gap-1.5 rounded-lg px-2 text-[12px] font-medium leading-none text-foreground";
+export declare const viewPrimaryControlClass = "h-7 gap-1.5 rounded-lg px-2 text-[12px] font-normal leading-none";
+export declare const viewSegmentControlClass = "h-7 gap-1 rounded-lg px-2 text-[12px] font-normal leading-none";
+export declare const viewPopoverContentClass = "rounded-lg border-border/70 bg-popover shadow-lg";
+export declare const viewListRowClass = "min-h-7 rounded-md px-1.5 text-[12px] leading-none";

package/dist/lib/view-chrome.js

@@ -0,0 +1,5 @@
+export const viewControlClass = 'h-7 gap-1.5 rounded-lg px-2 text-[12px] font-medium leading-none text-foreground';
+export const viewPrimaryControlClass = 'h-7 gap-1.5 rounded-lg px-2 text-[12px] font-normal leading-none';
+export const viewSegmentControlClass = 'h-7 gap-1 rounded-lg px-2 text-[12px] font-normal leading-none';
+export const viewPopoverContentClass = 'rounded-lg border-border/70 bg-popover shadow-lg';
+export const viewListRowClass = 'min-h-7 rounded-md px-1.5 text-[12px] leading-none';

package/dist/lib/view-query/config.d.ts

@@ -0,0 +1,26 @@
+import type { FieldRegistry, ViewQueryFieldMeta } from './model.js';
+import type { ViewQueryConfig } from './types.js';
+export interface ViewConfigShape<TDisplay> {
+    query: ViewQueryConfig;
+    display: TDisplay;
+}
+export interface DisplaySchema<TDisplay> {
+    read: (raw: Record<string, unknown>) => TDisplay;
+    write: (display: TDisplay) => Record<string, unknown>;
+    /** Keys this schema owns at the blob root, so writeViewConfig can strip stale copies. */
+    keys: readonly string[];
+}
+/** The budget a consumer whose table carries an octet_length CHECK should pass to writeViewConfig. */
+export declare const MAX_VIEW_CONFIG_BYTES: number;
+export interface WriteViewConfigOptions {
+    /** Reject a blob over this many bytes. Omit where no database constraint backs a limit. */
+    maxBytes?: number;
+}
+export { GROUP_ORDER_ALIASES, toInMemoryGroupOrder, toStoredGroupOrder } from './group-order.js';
+export declare function readViewConfig<TDisplay, TMeta extends ViewQueryFieldMeta = ViewQueryFieldMeta>(raw: unknown, registry: FieldRegistry<TMeta>, sortFields: ReadonlySet<string>, display: DisplaySchema<TDisplay>): ViewConfigShape<TDisplay>;
+export declare function writeViewConfig<TDisplay>(blob: unknown, next: ViewConfigShape<TDisplay>, display: DisplaySchema<TDisplay>, options?: WriteViewConfigOptions): Record<string, unknown>;
+/**
+ * The size Postgres will measure: `octet_length(config::text)` on a jsonb column, which
+ * re-serializes with a space after every `:` and `,` and counts UTF-8 bytes, not UTF-16 units.
+ */
+export declare function viewConfigByteLength(blob: unknown): number;