@ripple-ui/svelte 0.0.0-stage → 0.8.2

package/dist/widgets/composite/music-engine.js

@@ -0,0 +1,376 @@
+// widgets/composite/music-engine.ts: the sound behind the `music-player`
+// widget. Framework-free Web Audio synthesis, no files and no network: eight
+// generative presets (noise beds, swells, chirps, a lofi loop, a pad, slow
+// piano) that loop until paused.
+//
+// Invariants:
+// - Plain AudioNodes only (no AudioWorklet), so the landing CSP needs nothing.
+// - createEngine() returns null when there is no AudioContext (SSR, jsdom);
+//   callers keep their UI working without sound.
+// - Create it on a user gesture: browsers start a context suspended otherwise.
+// - Every change fades over FADE seconds; pause suspends the context after the
+//   fade; dispose() clears every timer and closes the context.
+// - Chain: voice -> master (volume) -> compressor -> analyser -> speakers.
+export const PRESETS = ['rain', 'brown-noise', 'white-noise', 'ocean', 'forest', 'lofi', 'drone', 'piano'];
+export const toPreset = (v) => PRESETS.includes(v) ? v : 'drone';
+const FADE = 0.5;
+const GAIN = 0.6;
+export function createEngine() {
+    const AC = typeof window === 'undefined'
+        ? undefined
+        : (window.AudioContext ?? window.webkitAudioContext);
+    if (!AC)
+        return null;
+    let ctx;
+    try {
+        ctx = new AC();
+    }
+    catch {
+        return null;
+    }
+    const master = ctx.createGain();
+    const comp = ctx.createDynamicsCompressor();
+    comp.threshold.value = -18;
+    comp.knee.value = 12;
+    comp.ratio.value = 6;
+    comp.attack.value = 0.01;
+    comp.release.value = 0.3;
+    const analyser = ctx.createAnalyser();
+    analyser.fftSize = 256;
+    analyser.smoothingTimeConstant = 0.8;
+    master.connect(comp).connect(analyser).connect(ctx.destination);
+    let volume = 0.7;
+    let muted = false;
+    const applyVolume = () => master.gain.setTargetAtTime(muted ? 0 : volume * GAIN, ctx.currentTime, 0.05);
+    master.gain.value = volume * GAIN;
+    const buffers = new Map();
+    function noise(kind) {
+        const hit = buffers.get(kind);
+        if (hit)
+            return hit;
+        const len = ctx.sampleRate * 4;
+        const b = ctx.createBuffer(1, len, ctx.sampleRate);
+        const d = b.getChannelData(0);
+        let last = 0;
+        for (let i = 0; i < len; i++) {
+            const w = Math.random() * 2 - 1;
+            if (kind === 'white')
+                d[i] = w;
+            else
+                d[i] = last = (last + 0.02 * w) / 1.02;
+        }
+        if (kind === 'brown') {
+            // Tilt the walk so the loop seam does not click, then normalise.
+            const drift = d[len - 1] - d[0];
+            let peak = 0;
+            for (let i = 0; i < len; i++)
+                peak = Math.max(peak, Math.abs((d[i] -= (drift * i) / (len - 1))));
+            for (let i = 0; i < len; i++)
+                d[i] /= peak || 1;
+        }
+        buffers.set(kind, b);
+        return b;
+    }
+    /** A voice: its own gain, the sources to stop, the timers to clear. */
+    function voice(build) {
+        const out = ctx.createGain();
+        out.gain.value = 0;
+        out.connect(master);
+        const v = { src: [], timers: [] };
+        build(out, v);
+        for (const s of v.src)
+            s.start();
+        return {
+            out,
+            stop() {
+                v.timers.forEach(clearInterval);
+                for (const s of v.src) {
+                    try {
+                        s.stop();
+                    }
+                    catch {
+                        /* already stopped */
+                    }
+                }
+                out.disconnect();
+            }
+        };
+    }
+    function loop(kind) {
+        const s = ctx.createBufferSource();
+        s.buffer = noise(kind);
+        s.loop = true;
+        return s;
+    }
+    function filter(type, freq, q = 0.7) {
+        const f = ctx.createBiquadFilter();
+        f.type = type;
+        f.frequency.value = freq;
+        f.Q.value = q;
+        return f;
+    }
+    function gain(g) {
+        const n = ctx.createGain();
+        n.gain.value = g;
+        return n;
+    }
+    function lfo(rate, depth, target) {
+        const o = ctx.createOscillator();
+        o.frequency.value = rate;
+        o.connect(gain(depth)).connect(target);
+        return o;
+    }
+    /** A short note or burst: `make` builds and starts the source at `t`. */
+    function blip(dest, t, peak, attack, decay, src, via) {
+        const g = ctx.createGain();
+        g.gain.setValueAtTime(0, t);
+        g.gain.linearRampToValueAtTime(peak, t + attack);
+        g.gain.exponentialRampToValueAtTime(0.0001, t + attack + decay);
+        (via ? src.connect(via) : src).connect(g).connect(dest);
+        src.start(t);
+        src.stop(t + attack + decay + 0.05);
+    }
+    function burst(dest, t, peak, decay, type, freq, q = 1) {
+        const s = ctx.createBufferSource();
+        s.buffer = noise('white');
+        blip(dest, t, peak, 0.002, decay, s, filter(type, freq, q));
+    }
+    function tone(dest, t, freq, peak, decay, type = 'sine', attack = 0.01) {
+        const o = ctx.createOscillator();
+        o.type = type;
+        o.frequency.value = freq;
+        blip(dest, t, peak, attack, decay, o);
+    }
+    /** A feedback delay with a dark tail: the reverb-ish send. */
+    function echo(dest, time, fb) {
+        const d = ctx.createDelay(2);
+        d.delayTime.value = time;
+        const f = filter('lowpass', 2400);
+        const g = gain(fb);
+        d.connect(f).connect(g).connect(d);
+        f.connect(dest);
+        return d;
+    }
+    const hz = (midi) => 440 * 2 ** ((midi - 69) / 12);
+    const every = (v, ms, fn) => v.timers.push(setInterval(fn, ms));
+    const builders = {
+        'white-noise': () => voice((bus, v) => {
+            const s = loop('white');
+            s.connect(filter('lowpass', 7000)).connect(gain(0.22)).connect(bus);
+            v.src.push(s);
+        }),
+        'brown-noise': () => voice((bus, v) => {
+            const s = loop('brown');
+            s.connect(filter('lowpass', 900)).connect(gain(0.9)).connect(bus);
+            v.src.push(s);
+        }),
+        rain: () => voice((bus, v) => {
+            const hiss = loop('white');
+            hiss.connect(filter('highpass', 500)).connect(filter('lowpass', 5000)).connect(gain(0.16)).connect(bus);
+            const bed = loop('brown');
+            bed.connect(filter('lowpass', 600)).connect(gain(0.5)).connect(bus);
+            v.src.push(hiss, bed);
+            every(v, 50, () => {
+                if (Math.random() < 0.35)
+                    burst(bus, ctx.currentTime + Math.random() * 0.05, 0.05 + Math.random() * 0.08, 0.03, 'bandpass', 1500 + Math.random() * 4000, 6);
+            });
+        }),
+        ocean: () => voice((bus, v) => {
+            const s = loop('brown');
+            const f = filter('lowpass', 700);
+            const swell = gain(0.55);
+            s.connect(f).connect(swell).connect(bus);
+            const a = lfo(0.09, 450, f.frequency);
+            const b = lfo(0.09, 0.4, swell.gain);
+            const foam = loop('white');
+            const ff = filter('bandpass', 2500, 0.5);
+            const fg = gain(0.04);
+            foam.connect(ff).connect(fg).connect(bus);
+            const c = lfo(0.09, 0.035, fg.gain);
+            v.src.push(s, a, b, foam, c);
+        }),
+        forest: () => voice((bus, v) => {
+            const wind = loop('brown');
+            const f = filter('bandpass', 500, 0.6);
+            wind.connect(f).connect(gain(0.45)).connect(bus);
+            const a = lfo(0.05, 250, f.frequency);
+            v.src.push(wind, a);
+            const room = echo(bus, 0.23, 0.3);
+            every(v, 450, () => {
+                if (Math.random() > 0.22)
+                    return;
+                const t = ctx.currentTime + 0.02;
+                const base = 2600 + Math.random() * 1600;
+                const n = 2 + Math.floor(Math.random() * 3);
+                for (let i = 0; i < n; i++) {
+                    const o = ctx.createOscillator();
+                    const at = t + i * 0.11;
+                    o.frequency.setValueAtTime(base, at);
+                    o.frequency.exponentialRampToValueAtTime(base * 1.5, at + 0.07);
+                    const g = ctx.createGain();
+                    g.gain.setValueAtTime(0, at);
+                    g.gain.linearRampToValueAtTime(0.05, at + 0.01);
+                    g.gain.exponentialRampToValueAtTime(0.0001, at + 0.08);
+                    o.connect(g);
+                    g.connect(bus);
+                    g.connect(room);
+                    o.start(at);
+                    o.stop(at + 0.1);
+                }
+            });
+        }),
+        drone: () => voice((bus, v) => {
+            const f = filter('lowpass', 520, 1);
+            const g = gain(0.09);
+            f.connect(g).connect(bus);
+            for (const [m, det] of [
+                [45, -6],
+                [45, 6],
+                [52, -3],
+                [57, 4],
+                [33, 0]
+            ]) {
+                const o = ctx.createOscillator();
+                o.type = m === 33 ? 'sine' : 'sawtooth';
+                o.frequency.value = hz(m);
+                o.detune.value = det;
+                if (m === 33)
+                    o.connect(gain(0.2)).connect(bus);
+                else
+                    o.connect(f);
+                v.src.push(o);
+            }
+            v.src.push(lfo(0.04, 220, f.frequency));
+        }),
+        lofi: () => voice((bus, v) => {
+            const keys = filter('lowpass', 1400);
+            const kg = gain(1);
+            keys.connect(kg).connect(bus);
+            keys.connect(echo(bus, 0.4, 0.25));
+            const crackle = loop('white');
+            crackle.connect(filter('highpass', 3000)).connect(gain(0.012)).connect(bus);
+            v.src.push(crackle);
+            // Cmaj7, Am7, Dm7, G7 as MIDI; one bar each at 76 bpm.
+            const chords = [
+                [48, 55, 59, 64],
+                [45, 52, 55, 60],
+                [50, 57, 60, 65],
+                [43, 50, 53, 59]
+            ];
+            const step = 60 / 76 / 2;
+            let n = 0;
+            let next = ctx.currentTime + 0.1;
+            every(v, 50, () => {
+                while (next < ctx.currentTime + 0.25) {
+                    const s = n % 8;
+                    const bar = Math.floor(n / 8) % chords.length;
+                    if (s === 0)
+                        for (const m of chords[bar])
+                            tone(keys, next, hz(m), 0.05, step * 7.5, 'triangle', 0.04);
+                    if (s === 3 || s === 6)
+                        tone(keys, next, hz(chords[bar][2] + 12), 0.025, step * 2, 'sine', 0.02);
+                    if (s === 0 || s === 5) {
+                        const o = ctx.createOscillator();
+                        o.frequency.setValueAtTime(110, next);
+                        o.frequency.exponentialRampToValueAtTime(45, next + 0.12);
+                        blip(bus, next, 0.35, 0.003, 0.25, o);
+                    }
+                    if (s === 2 || s === 6)
+                        burst(bus, next, 0.07, 0.12, 'bandpass', 1800, 0.8);
+                    burst(bus, next, s % 2 ? 0.015 : 0.025, 0.04, 'highpass', 7000);
+                    next += step;
+                    n++;
+                }
+            });
+        }),
+        piano: () => voice((bus, v) => {
+            const dry = gain(1);
+            dry.connect(bus);
+            dry.connect(echo(bus, 0.37, 0.42));
+            const scale = [60, 62, 64, 67, 69, 72, 74, 76, 79, 81];
+            let wait = 0;
+            let i = 4;
+            every(v, 100, () => {
+                if ((wait -= 0.1) > 0)
+                    return;
+                wait = 0.7 + Math.random() * 1.1;
+                i = Math.min(Math.max(i + Math.round((Math.random() - 0.5) * 4), 0), scale.length - 1);
+                const t = ctx.currentTime + 0.02;
+                const f = hz(scale[i]);
+                tone(dry, t, f, 0.12, 2.8, 'sine', 0.005);
+                tone(dry, t, f * 2, 0.03, 1.2, 'triangle', 0.005);
+                if (Math.random() < 0.3)
+                    tone(dry, t, f / 2, 0.06, 3, 'sine', 0.01);
+            });
+            // A held low note under it, so a gap is never silence.
+            const pad = ctx.createOscillator();
+            pad.frequency.value = hz(48);
+            pad.connect(gain(0.03)).connect(bus);
+            v.src.push(pad);
+        })
+    };
+    let current = null;
+    let currentPreset = null;
+    let suspendTimer;
+    function fadeOut(v) {
+        const t = ctx.currentTime;
+        v.out.gain.cancelScheduledValues(t);
+        v.out.gain.setValueAtTime(v.out.gain.value, t);
+        v.out.gain.linearRampToValueAtTime(0, t + FADE);
+        setTimeout(v.stop, FADE * 1000 + 100);
+    }
+    return {
+        play(preset) {
+            clearTimeout(suspendTimer);
+            if (ctx.state !== 'running')
+                void ctx.resume().catch(() => { });
+            if (current && currentPreset === preset) {
+                const t = ctx.currentTime;
+                current.out.gain.cancelScheduledValues(t);
+                current.out.gain.setValueAtTime(current.out.gain.value, t);
+                current.out.gain.linearRampToValueAtTime(1, t + FADE);
+                return;
+            }
+            if (current)
+                fadeOut(current);
+            current = builders[preset]();
+            currentPreset = preset;
+            current.out.gain.setValueAtTime(0, ctx.currentTime);
+            current.out.gain.linearRampToValueAtTime(1, ctx.currentTime + FADE);
+        },
+        pause() {
+            if (current)
+                fadeOut(current);
+            current = null;
+            currentPreset = null;
+            clearTimeout(suspendTimer);
+            suspendTimer = setTimeout(() => void ctx.suspend().catch(() => { }), FADE * 1000 + 150);
+        },
+        setVolume(v) {
+            volume = Math.min(Math.max(v, 0), 1);
+            applyVolume();
+        },
+        setMuted(m) {
+            muted = m;
+            applyVolume();
+        },
+        level() {
+            const d = new Float32Array(analyser.fftSize);
+            analyser.getFloatTimeDomainData(d);
+            let s = 0;
+            for (const x of d)
+                s += x * x;
+            return Math.sqrt(s / d.length);
+        },
+        spectrum(out) {
+            analyser.getByteFrequencyData(out);
+        },
+        state: () => ctx.state,
+        dispose() {
+            clearTimeout(suspendTimer);
+            current?.stop();
+            current = null;
+            void ctx.close().catch(() => { });
+        }
+    };
+}

package/dist/widgets/composite/notes.d.ts

@@ -0,0 +1,49 @@
+export declare const MAX_NOTES = 50;
+export declare const MAX_TITLE = 80;
+export declare const MAX_TEXT = 2000;
+export declare const MAX_TAGS = 8;
+export declare const MAX_TAG = 24;
+export declare const NOTE_COLORS: readonly ["plain", "yellow", "blue", "green", "pink"];
+export type NoteColor = (typeof NOTE_COLORS)[number];
+export interface Note {
+    id: string;
+    title: string;
+    text: string;
+    tags: string[];
+    pinned: boolean;
+    color: NoteColor;
+    /** Epoch ms of the visitor's last save. Model notes have none. */
+    at?: number;
+}
+export interface NotesValue {
+    notes: Note[];
+}
+export declare function cleanTag(v: unknown): string;
+export declare function cleanTags(raw: Iterable<unknown>, max?: number): string[];
+/** Pull `#tags` out of a line of writing: the text without them, and the tags. */
+export declare function parseTags(s: string): {
+    text: string;
+    tags: string[];
+};
+/** The first free `nN` id. */
+export declare function nextNoteId(notes: readonly {
+    id: string;
+}[]): string;
+/** Up to 50 notes with a title or text and unique ids. Strings are text-only notes. */
+export declare function readNotes(raw: unknown): Note[];
+/** A bound or edited value, cleaned; undefined when it carries no notes key. */
+export declare function toValue(raw: unknown): NotesValue | undefined;
+/** Pinned first, otherwise array order (newest first, since new notes go on top). */
+export declare const ordered: (notes: readonly Note[]) => Note[];
+/** Tags on notes (most used first), then the suggested ones. */
+export declare function allTags(notes: readonly Note[], suggested: unknown): string[];
+export declare function matches(n: Note, tag: string, query: string): boolean;
+/** "just now", "5 min ago", "3 h ago", "2 d ago". */
+export declare function ago(at: number, now: number): string;
+/** A note's writing as the editor shows it: tags back at the end as `#tag`. */
+export declare const asDraft: (n: Note) => {
+    title: string;
+    text: string;
+};
+/** Editor writing to note fields, or null when there is nothing written. */
+export declare function fromDraft(title: string, text: string): Pick<Note, 'title' | 'text' | 'tags'> | null;

package/dist/widgets/composite/notes.js

@@ -0,0 +1,130 @@
+// widgets/composite/notes.ts: the plain logic behind the notes widget: the
+// normaliser that turns model props (or a bound value) into a clean NotesValue,
+// inline `#tag` parsing, the tag list, filtering and the relative-time label.
+//
+// Invariants:
+// - Everything is plain text. Caps hold here, not in the markup: 50 notes,
+//   title 80, text 2000, 8 tags of 24 chars per note.
+// - A tag is lowercase letters, digits, `-` or `_` after a `#` that starts a
+//   word; parsing strips it from the text so the card shows it as a chip.
+// - Ids are unique; an id-less note gets `n${index + 1}`, so a streamed note
+//   keeps its id as the rest of the array arrives.
+import { plain } from '../data-kit/format.js';
+import { list, rec } from './recipe.js';
+export const MAX_NOTES = 50;
+export const MAX_TITLE = 80;
+export const MAX_TEXT = 2000;
+export const MAX_TAGS = 8;
+export const MAX_TAG = 24;
+export const NOTE_COLORS = ['plain', 'yellow', 'blue', 'green', 'pink'];
+const TAG_RE = /(^|\s)#([\p{L}\p{N}_-]+)[ \t]?/gu;
+export function cleanTag(v) {
+    const t = (typeof v === 'string' ? v : '').trim().replace(/^#/, '').toLowerCase();
+    return /^[\p{L}\p{N}_-]+$/u.test(t) ? t.slice(0, MAX_TAG) : '';
+}
+export function cleanTags(raw, max = MAX_TAGS) {
+    return [...new Set([...raw].map(cleanTag).filter(Boolean))].slice(0, max);
+}
+/** Pull `#tags` out of a line of writing: the text without them, and the tags. */
+export function parseTags(s) {
+    const tags = [];
+    const text = s
+        .replace(TAG_RE, (_m, lead, tag) => {
+        tags.push(tag);
+        return lead;
+    })
+        .replace(/[ \t]{2,}/g, ' ')
+        .replace(/ +([,.;:!?])/g, '$1')
+        .replace(/[ \t]+$/gm, '')
+        .trim();
+    return { text, tags: cleanTags(tags) };
+}
+const isColor = (v) => NOTE_COLORS.includes(v);
+/** The first free `nN` id. */
+export function nextNoteId(notes) {
+    const used = new Set(notes.map((n) => n.id));
+    let n = notes.length + 1;
+    while (used.has(`n${n}`))
+        n++;
+    return `n${n}`;
+}
+/** Up to 50 notes with a title or text and unique ids. Strings are text-only notes. */
+export function readNotes(raw) {
+    const out = [];
+    const ids = new Set();
+    list(raw).forEach((r, i) => {
+        if (out.length >= MAX_NOTES)
+            return;
+        const n = typeof r === 'string' ? { text: r } : rec(r);
+        const title = plain(n.title).slice(0, MAX_TITLE);
+        const text = plain(n.text).slice(0, MAX_TEXT);
+        if (!title && !text)
+            return;
+        let id = typeof n.id === 'string' || typeof n.id === 'number' ? String(n.id).trim() : '';
+        if (!id)
+            id = `n${i + 1}`;
+        if (ids.has(id))
+            id = `${id}-${i}`;
+        ids.add(id);
+        const at = typeof n.at === 'number' && Number.isFinite(n.at) ? n.at : undefined;
+        out.push({
+            id,
+            title,
+            text,
+            tags: cleanTags(list(n.tags)),
+            pinned: n.pinned === true,
+            color: isColor(n.color) ? n.color : 'plain',
+            ...(at === undefined ? {} : { at })
+        });
+    });
+    return out;
+}
+/** A bound or edited value, cleaned; undefined when it carries no notes key. */
+export function toValue(raw) {
+    const r = rec(raw);
+    return Array.isArray(r.notes) ? { notes: readNotes(r.notes) } : undefined;
+}
+/** Pinned first, otherwise array order (newest first, since new notes go on top). */
+export const ordered = (notes) => [...notes.filter((n) => n.pinned), ...notes.filter((n) => !n.pinned)];
+/** Tags on notes (most used first), then the suggested ones. */
+export function allTags(notes, suggested) {
+    const count = new Map();
+    for (const n of notes)
+        for (const t of n.tags)
+            count.set(t, (count.get(t) ?? 0) + 1);
+    const used = [...count.keys()].sort((a, b) => count.get(b) - count.get(a));
+    return cleanTags([...used, ...list(suggested)], 24);
+}
+export function matches(n, tag, query) {
+    if (tag && !n.tags.includes(tag))
+        return false;
+    const q = query.trim().toLowerCase();
+    return !q || `${n.title}\n${n.text}\n${n.tags.join(' ')}`.toLowerCase().includes(q);
+}
+/** "just now", "5 min ago", "3 h ago", "2 d ago". */
+export function ago(at, now) {
+    const s = Math.max(0, Math.round((now - at) / 1000));
+    if (s < 60)
+        return 'just now';
+    if (s < 3600)
+        return `${Math.floor(s / 60)} min ago`;
+    if (s < 86400)
+        return `${Math.floor(s / 3600)} h ago`;
+    return `${Math.floor(s / 86400)} d ago`;
+}
+/** A note's writing as the editor shows it: tags back at the end as `#tag`. */
+export const asDraft = (n) => ({
+    title: n.title,
+    text: [n.text, n.tags.map((t) => `#${t}`).join(' ')].filter(Boolean).join(n.text ? '\n' : '')
+});
+/** Editor writing to note fields, or null when there is nothing written. */
+export function fromDraft(title, text) {
+    const a = parseTags(title);
+    const b = parseTags(text);
+    const t = a.text.slice(0, MAX_TITLE);
+    const x = b.text.slice(0, MAX_TEXT);
+    const tags = cleanTags([...a.tags, ...b.tags]);
+    if (!t && !x && !tags.length)
+        return null;
+    return { title: t, text: x, tags };
+}

package/dist/widgets/composite/order-status-data.d.ts

@@ -0,0 +1,74 @@
+export type DefaultStatus = 'placed' | 'confirmed' | 'preparing' | 'in-transit' | 'out-for-delivery' | 'delivered' | 'ready-for-pickup' | 'picked-up' | 'failed' | 'cancelled';
+export type StepState = 'done' | 'active' | 'pending' | 'failed';
+export type Pipeline = 'delivery' | 'pickup' | 'custom';
+export type LatLng = [number, number];
+export interface Step {
+    id: string;
+    label: string;
+    description: string;
+    completedAt: string;
+}
+export interface Progress {
+    pipeline: Pipeline;
+    steps: Step[];
+    states: StepState[];
+    /** The current (or failed, or last when finished) step; -1 when the rail is hidden. */
+    active: number;
+    finished: boolean;
+    /** 'failed' or 'cancelled' when the order went wrong, else undefined. */
+    bad: 'failed' | 'cancelled' | undefined;
+    showRail: boolean;
+}
+/** Updates shown before the fold. */
+export declare const EVENT_FOLD = 4;
+/** The written status folded to a key: trimmed, lower case, spaces and underscores to `-`. */
+export declare function statusKey(v: unknown): string;
+/** A known status, through the aliases; anything else is undefined. */
+export declare function normStatus(v: unknown): DefaultStatus | undefined;
+/** The step list and per-step states (see the rule in the header). */
+export declare function progress(rawSteps: unknown, rawStatus: unknown, currentStep: unknown): Progress;
+/** The card's headline: the title, else what the steps say now. */
+export declare function headline(title: unknown, p: Progress): string;
+/**
+ * The word before the ETA value, or '' when the value already opens with the
+ * label's first word ("Next attempt tomorrow" needs no "Next step").
+ */
+export declare function etaLabel(p: Progress, eta?: string): string;
+export interface CleanEvent {
+    key: string;
+    label: string;
+    time: string;
+    location: string;
+    icon: string;
+}
+/** Events as given (newest first, never sorted); a label-less one is dropped. */
+export declare function cleanEvents(raw: unknown): CleanEvent[];
+export type Variant = 'default' | 'outline' | 'ghost';
+export interface CleanAction<H> {
+    key: string;
+    id: string;
+    label: string;
+    icon: string;
+    variant: Variant;
+    actions: H | undefined;
+}
+/** Actions that can do something: one with neither an id nor handlers is dropped. */
+export declare function cleanActions<H = unknown>(raw: unknown): CleanAction<H>[];
+/** A finite [lat, lng] from a pair or a {lat, lng} object; 0 counts, strings do not. */
+export declare function point(v: unknown): LatLng | undefined;
+export interface CleanPlace {
+    name: string;
+    address: string;
+    at: LatLng | undefined;
+    /** Drawn in the From / To list (it has a name or an address). */
+    listed: boolean;
+}
+/** A place with plain text and a finite point; `fallback` names it only when an address exists. */
+export declare function cleanPlace(v: unknown, fallback: string): CleanPlace | undefined;
+export interface CleanTracking {
+    carrier: string;
+    number: string;
+    url: string;
+}
+/** Carrier and number as text (a model may send numbers); no number, no tracking. */
+export declare function cleanTracking(v: unknown): CleanTracking | undefined;