@ripple-ui/svelte 0.0.0-stage → 0.8.2

package/dist/widgets/composite/exercise-figures.js

@@ -0,0 +1,467 @@
+// widgets/composite/exercise-figures.ts — the curated library of animated
+// exercise figures for `interval-workout`. Each figure is a line person posed
+// by joint angles (keyframes below) and turned into a fixed SVG string at
+// module load: our code, never model output. The widget picks one by name
+// (matchFigure) or by an explicit `figure` id.
+//
+// Invariants:
+// - Every string is built here from numbers only. Nothing from a spec or a
+//   prop ever reaches these strings, so rendering them with {@html} is safe.
+// - Animation is SMIL only (<animate> on path `d` and circle cx/cy). No
+//   scripts, no external refs, no event attributes.
+// - `still` is the same figure with no animation elements, frozen on the key
+//   pose: list rows and reduced motion use it.
+// - Angles: 0 points down, 90 forward (right, the way side-view figures
+//   face), 180 up, -90 back. Each limb segment is absolute, not relative.
+const TORSO = 18;
+const UPPER = 10;
+const FORE = 9;
+const THIGH = 12;
+const SHIN = 12;
+const HEAD_R = 4.5;
+const HEAD_OFF = 7.5;
+const SHOULDER_W = 4.5;
+const HIP_W = 2.5;
+const GROUND = 56;
+const ACCENT = '#1877F2';
+const STAND = { t: 180, l: [0, 0] };
+const RUN_A = [-35, 50];
+const RUN_B = [40, 130];
+const PLANK = { t: 117, l: [-63, -63] };
+const DEFS = {
+    // ── Yoga ────────────────────────────────────────────────────────────────
+    'mountain-pose': {
+        aliases: ['mountain', 'tadasana', 'upward salute', 'samasthiti'],
+        dur: 4,
+        front: true,
+        key: 1,
+        poses: [
+            { t: 180, a: [12, 6], l: [4, 2] },
+            { t: 180, a: [165, 175], l: [4, 2] }
+        ]
+    },
+    'cat-cow': {
+        aliases: ['cat cow', 'cat and cow', 'cat camel', 'marjaryasana', 'bitilasana', 'cat', 'cow'],
+        dur: 4,
+        anchor: 'hip',
+        key: 1,
+        poses: [
+            { t: 110, b: 3.5, h: 45, a: [0, 0], l: [0, -90] },
+            { t: 110, b: -4.5, h: -70, a: [0, 0], l: [0, -90] }
+        ]
+    },
+    'downward-dog': {
+        aliases: ['downward dog', 'down dog', 'downdog', 'downward facing dog', 'adho mukha svanasana'],
+        dur: 3,
+        anchor: 'wrist',
+        poses: [
+            { t: 55, h: -10, a: [55, 55], l: [-12, -55], L: [-25, -25] },
+            { t: 55, h: -10, a: [55, 55], l: [-25, -25], L: [-12, -55] }
+        ]
+    },
+    'childs-pose': {
+        aliases: ['childs pose', 'child', 'balasana', 'extended child'],
+        dur: 4.5,
+        anchor: 'hip',
+        poses: [
+            { t: 68, b: -2.5, h: -20, a: [92, 90], l: [35, -90] },
+            { t: 74, b: -4, h: -18, a: [91, 90], l: [35, -90] }
+        ]
+    },
+    cobra: {
+        aliases: ['cobra', 'bhujangasana', 'baby cobra', 'sphinx', 'upward dog', 'upward facing dog'],
+        dur: 3.5,
+        anchor: 'ankle',
+        key: 1,
+        poses: [
+            { t: 100, a: [-114, 37], l: [-90, -90] },
+            { t: 140, h: 25, a: [-30, 55], l: [-90, -90] }
+        ]
+    },
+    'warrior-one': {
+        aliases: ['warrior one', 'warrior 1', 'warrior i', 'virabhadrasana i', 'virabhadrasana 1', 'crescent lunge', 'high lunge'],
+        dur: 3.5,
+        key: 1,
+        poses: [
+            { t: 180, a: [20, 150], l: [60, 0], L: [-45, -45] },
+            { t: 180, h: 10, a: [172, 178], l: [60, 0], L: [-45, -45] }
+        ]
+    },
+    'warrior-two': {
+        aliases: ['warrior two', 'warrior 2', 'warrior ii', 'virabhadrasana ii', 'virabhadrasana 2'],
+        dur: 3.5,
+        front: true,
+        anchor: 'hip',
+        key: 1,
+        poses: [
+            { t: 180, a: [15, 10], l: [35, 35], L: [-35, -35] },
+            { t: 180, a: [90, 90], l: [62, 10], L: [-38, -38] }
+        ]
+    },
+    'tree-pose': {
+        aliases: ['tree', 'vrksasana', 'vriksasana'],
+        dur: 4,
+        front: true,
+        key: 1,
+        poses: [
+            { t: 180, a: [25, -145], A: [-25, 145], l: [0, 0], L: [-95, 50] },
+            { t: 180, a: [155, -160], A: [-155, 160], l: [0, 0], L: [-95, 50] }
+        ]
+    },
+    bridge: {
+        aliases: ['bridge', 'setu bandhasana', 'setu bandha sarvangasana'],
+        dur: 4,
+        key: 1,
+        poses: [
+            { t: -90, a: [90, 90], l: [145, 5] },
+            { t: -56, h: -34, a: [90, 90], l: [99, -4] }
+        ]
+    },
+    'seated-forward-fold': {
+        aliases: ['seated forward fold', 'seated forward bend', 'paschimottanasana', 'forward fold', 'forward bend', 'hamstring stretch', 'sit and reach'],
+        dur: 4.5,
+        anchor: 'hip',
+        key: 1,
+        poses: [
+            { t: 175, a: [168, 175], l: [90, 90] },
+            { t: 132, b: -3, h: -20, a: [108, 100], l: [90, 90] }
+        ]
+    },
+    triangle: {
+        aliases: ['triangle', 'trikonasana', 'extended triangle'],
+        dur: 4,
+        front: true,
+        anchor: 'hip',
+        key: 1,
+        poses: [
+            { t: 180, a: [90, 90], A: [-90, -90], l: [32, 32], L: [-32, -32] },
+            { t: 115, a: [25, 25], A: [205, 205], l: [32, 32], L: [-32, -32] }
+        ]
+    },
+    plank: {
+        aliases: ['plank', 'high plank', 'forearm plank', 'plank hold', 'shoulder tap', 'plank shoulder tap', 'phalakasana'],
+        dur: 2.4,
+        poses: [
+            { ...PLANK, h: 5, a: [0, 0], A: [0, 0] },
+            { ...PLANK, h: 5, a: [60, -120], A: [0, 0] }
+        ]
+    },
+    // ── HIIT and strength ───────────────────────────────────────────────────
+    'jumping-jacks': {
+        aliases: ['jumping jack', 'star jump', 'jack'],
+        dur: 1.2,
+        front: true,
+        anchor: 'hip',
+        key: 2,
+        poses: [
+            { t: 180, a: [10, 5], l: [3, 0] },
+            { t: 180, a: [90, 100], l: [13, 12], y: 4 },
+            { t: 180, a: [160, 170], l: [24, 24] },
+            { t: 180, a: [90, 100], l: [13, 12], y: 4 }
+        ]
+    },
+    squat: {
+        aliases: ['squat', 'air squat', 'bodyweight squat', 'goblet squat', 'sumo squat', 'chair', 'utkatasana'],
+        dur: 2.4,
+        key: 1,
+        poses: [
+            { ...STAND, a: [5, 10] },
+            { t: 145, h: 25, a: [90, 90], l: [85, -20] }
+        ]
+    },
+    lunge: {
+        aliases: ['lunge', 'reverse lunge', 'forward lunge', 'walking lunge', 'alternating lunge', 'split squat'],
+        dur: 2.6,
+        key: 1,
+        poses: [
+            { ...STAND, a: [10, 5] },
+            { t: 180, a: [10, 5], l: [85, 0], L: [-15, -80] }
+        ]
+    },
+    'push-up': {
+        aliases: ['push up', 'pushup', 'press up', 'knee push up', 'incline push up', 'tricep push up', 'chaturanga'],
+        dur: 2,
+        poses: [
+            { ...PLANK, h: 5, a: [0, 0] },
+            { t: 100, h: 5, a: [-86, 43], l: [-80, -80] }
+        ]
+    },
+    burpee: {
+        aliases: ['burpee', 'half burpee', 'squat thrust'],
+        dur: 3,
+        key: 2,
+        poses: [
+            { ...STAND, a: [10, 5] },
+            { t: 110, h: 20, a: [0, 0], l: [75, -35] },
+            { ...PLANK, a: [0, 0], k: 'wrist' },
+            { t: 110, h: 20, a: [0, 0], l: [75, -35], k: 'wrist' },
+            { ...STAND, a: [10, 5] },
+            { ...STAND, a: [170, 175], y: 6 }
+        ]
+    },
+    'mountain-climbers': {
+        aliases: ['mountain climber', 'climber', 'cross body mountain climber'],
+        dur: 1,
+        anchor: 'wrist',
+        poses: [
+            { t: 117, a: [0, 0], l: [75, -60], L: [-63, -63] },
+            { t: 117, a: [0, 0], l: [-63, -63], L: [75, -60] }
+        ]
+    },
+    'high-knees': {
+        aliases: ['high knee', 'knee raise', 'marching', 'march in place', 'high knee run'],
+        dur: 0.8,
+        anchor: 'hip',
+        poses: [
+            { t: 180, a: RUN_A, A: RUN_B, l: [90, 0], L: [0, 0] },
+            { t: 180, a: RUN_B, A: RUN_A, l: [0, 0], L: [90, 0] }
+        ]
+    },
+    'sit-up': {
+        aliases: ['sit up', 'situp', 'crunch', 'ab crunch', 'abdominal crunch', 'curl up', 'v up'],
+        dur: 2.2,
+        key: 1,
+        poses: [
+            { t: -90, a: [-70, 60], l: [140, 10] },
+            { t: -135, a: [-115, 15], l: [140, 10] }
+        ]
+    },
+    'glute-bridge': {
+        aliases: ['glute bridge', 'hip bridge', 'hip raise', 'hip thrust', 'butt bridge'],
+        dur: 2.2,
+        key: 1,
+        poses: [
+            { t: -90, a: [90, 90], l: [145, 5] },
+            { t: -56, h: -34, a: [90, 90], l: [99, -4] }
+        ]
+    },
+    'side-plank': {
+        aliases: ['side plank', 'side plank hold', 'vasisthasana'],
+        dur: 3,
+        poses: [
+            { ...PLANK, a: [0, 0], A: [180, 180] },
+            { ...PLANK, b: 3, a: [0, 0], A: [150, 150] }
+        ]
+    },
+    'jump-squat': {
+        aliases: ['jump squat', 'squat jump', 'plyo squat', 'frog jump'],
+        dur: 1.6,
+        poses: [
+            { t: 145, h: 25, a: [-25, -15], l: [85, -20] },
+            { t: 180, a: [160, 170], l: [0, 5], y: 7 }
+        ]
+    },
+    'butt-kicks': {
+        aliases: ['butt kick', 'butt kicker', 'heel kick', 'heel flick'],
+        dur: 0.8,
+        anchor: 'hip',
+        poses: [
+            { t: 180, a: RUN_A, A: RUN_B, l: [-8, -165], L: [0, 0] },
+            { t: 180, a: RUN_B, A: RUN_A, l: [0, 0], L: [-8, -165] }
+        ]
+    },
+    'arm-circles': {
+        aliases: ['arm circle', 'shoulder circle', 'arm swing', 'arm rotation'],
+        dur: 1.2,
+        front: true,
+        anchor: 'hip',
+        poses: [
+            { t: 180, a: [80, 80], l: [4, 2] },
+            { t: 180, a: [90, 96], l: [4, 2] },
+            { t: 180, a: [100, 100], l: [4, 2] },
+            { t: 180, a: [90, 84], l: [4, 2] }
+        ]
+    },
+    'wall-sit': {
+        aliases: ['wall sit', 'wall squat', 'wall chair'],
+        dur: 3,
+        wall: true,
+        poses: [
+            { t: 180, a: [80, 90], l: [90, 0] },
+            { t: 180, b: 0.8, a: [76, 92], l: [90, 0] }
+        ]
+    },
+    superman: {
+        aliases: ['superman', 'superman hold', 'swimmer', 'back extension', 'locust', 'salabhasana'],
+        dur: 2.6,
+        anchor: 'hip',
+        key: 1,
+        poses: [
+            { t: 93, a: [95, 95], l: [-93, -93] },
+            { t: 108, h: 12, a: [122, 122], l: [-110, -110] }
+        ]
+    },
+    'bicycle-crunch': {
+        aliases: ['bicycle crunch', 'bicycle', 'bicycle kick', 'bicycle sit up'],
+        dur: 1.4,
+        anchor: 'hip',
+        poses: [
+            { t: -125, h: -10, a: [-105, 25], l: [150, 80], L: [100, 95] },
+            { t: -125, h: -10, a: [-105, 25], l: [100, 95], L: [150, 80] }
+        ]
+    },
+    'running-in-place': {
+        aliases: ['running in place', 'run in place', 'jog in place', 'jogging', 'jog', 'running', 'run', 'sprint'],
+        dur: 0.7,
+        anchor: 'hip',
+        poses: [
+            { t: 175, a: RUN_A, A: RUN_B, l: [40, -20], L: [-20, -80] },
+            { t: 175, a: RUN_B, A: RUN_A, l: [-20, -80], L: [40, -20] }
+        ]
+    },
+    stretch: {
+        aliases: ['stretch', 'stretching', 'side stretch', 'standing stretch', 'overhead stretch', 'side bend', 'cool down', 'cooldown', 'warm up', 'warmup'],
+        dur: 4,
+        front: true,
+        anchor: 'hip',
+        key: 1,
+        poses: [
+            { t: 180, a: [170, 178], l: [4, 2] },
+            { t: 160, a: [140, 150], A: [170, 165], l: [4, 2] },
+            { t: 180, a: [170, 178], l: [4, 2] },
+            { t: 200, a: [-170, -165], A: [-140, -150], l: [4, 2] }
+        ]
+    },
+    rest: {
+        aliases: ['rest', 'break', 'recover', 'recovery', 'breathe', 'breathing', 'breath', 'water break', 'relax', 'meditation', 'meditate', 'easy pose', 'sukhasana'],
+        dur: 4.5,
+        front: true,
+        anchor: 'hip',
+        poses: [
+            { t: 180, a: [15, 0], l: [75, -100] },
+            { t: 180, a: [19, 3], l: [75, -100], y: 1 }
+        ]
+    }
+};
+// ── Geometry ──────────────────────────────────────────────────────────────
+const RAD = Math.PI / 180;
+const dir = (deg, len) => [Math.sin(deg * RAD) * len, Math.cos(deg * RAD) * len];
+const add = (p, q) => [p[0] + q[0], p[1] + q[1]];
+const mirror = (s) => [-s[0], -s[1]];
+const neg = (q) => [-q[0], -q[1]];
+/** Root, joint offset (shoulder or hip width in front view), elbow or knee, wrist or ankle. */
+function limb(root, off, [u, f], l1, l2) {
+    const from = add(root, off);
+    const mid = add(from, dir(u, l1));
+    return [root, from, mid, add(mid, dir(f, l2))];
+}
+function skeleton(p, front) {
+    const hip = [0, 0];
+    const sh = dir(p.t, TORSO);
+    const bend = dir(p.t - 90, p.b ?? 0);
+    const half = dir(p.t, TORSO / 2);
+    const far = (s, near) => s ?? (front ? mirror(near) : near);
+    const shW = front ? dir(p.t - 90, SHOULDER_W) : [0, 0];
+    const hipW = front ? dir(p.t - 90, HIP_W) : [0, 0];
+    return {
+        hip,
+        sh,
+        ctrl: add(half, [bend[0] * 2, bend[1] * 2]),
+        low: add(half, bend),
+        head: add(sh, dir(p.t + (p.h ?? 0), HEAD_OFF)),
+        arms: [limb(sh, neg(shW), far(p.A, p.a), UPPER, FORE), limb(sh, shW, p.a, UPPER, FORE)],
+        legs: [limb(hip, neg(hipW), far(p.L, p.l), THIGH, SHIN), limb(hip, hipW, p.l, THIGH, SHIN)]
+    };
+}
+const points = (f) => [f.hip, f.sh, f.low, ...f.arms.flat(), ...f.legs.flat()];
+const joint = (f, j) => (j === 'hip' ? f.hip : j === 'wrist' ? f.arms[1][3] : f.legs[1][3]);
+function move(f, fn) {
+    return {
+        hip: fn(f.hip),
+        ctrl: fn(f.ctrl),
+        sh: fn(f.sh),
+        head: fn(f.head),
+        low: fn(f.low),
+        arms: [f.arms[0].map(fn), f.arms[1].map(fn)],
+        legs: [f.legs[0].map(fn), f.legs[1].map(fn)]
+    };
+}
+/** Frames on the floor, chained so the anchor joint holds still, then fit to the 64 box. */
+function layout(def) {
+    const placed = [];
+    def.poses.forEach((pose, i) => {
+        const f = skeleton(pose, !!def.front);
+        const lowest = Math.max(...points(f).map((p) => p[1]), f.head[1] + HEAD_R);
+        const dy = GROUND - lowest - (pose.y ?? 0);
+        const j = pose.k ?? def.anchor ?? 'ankle';
+        const dx = i === 0 ? 0 : joint(placed[i - 1], j)[0] - joint(f, j)[0];
+        placed.push(move(f, (p) => [p[0] + dx, p[1] + dy]));
+    });
+    const all = placed.flatMap((f) => [...points(f), [f.head[0] - HEAD_R, f.head[1] - HEAD_R], [f.head[0] + HEAD_R, f.head[1] + HEAD_R]]);
+    const xs = all.map((p) => p[0]);
+    const top = Math.min(...all.map((p) => p[1]));
+    const left = Math.min(...xs);
+    const right = Math.max(...xs);
+    const s = Math.min(1, 52 / (right - left), (GROUND - 4) / (GROUND - top));
+    const cx = (left + right) / 2;
+    return placed.map((f) => move(f, (p) => [32 + (p[0] - cx) * s, GROUND - (GROUND - p[1]) * s]));
+}
+// ── SVG ───────────────────────────────────────────────────────────────────
+const n = (v) => String(Math.round(v * 10) / 10);
+const xy = (p) => `${n(p[0])} ${n(p[1])}`;
+const line = (ps) => `M${xy(ps[0])}L${ps.slice(1).map(xy).join(' ')}`;
+const spine = (f) => `M${xy(f.hip)}Q${xy(f.ctrl)} ${xy(f.sh)}`;
+function anim(attr, values, dur) {
+    const v = [...values, values[0]];
+    const steps = v.length - 1;
+    const times = v.map((_, i) => n(i / steps)).join(';');
+    const splines = Array.from({ length: steps }, () => '.42 0 .58 1').join(';');
+    return `<animate attributeName="${attr}" dur="${dur}s" repeatCount="indefinite" calcMode="spline" keyTimes="${times}" keySplines="${splines}" values="${v.join(';')}"/>`;
+}
+function build(def, animated) {
+    const frames = layout(def);
+    const key = frames[def.key ?? 0];
+    const go = animated && frames.length > 1;
+    const path = (get, extra = '') => `<path${extra} d="${get(key)}">${go ? anim('d', frames.map(get), def.dur) : ''}</path>`;
+    const head = `<circle cx="${n(key.head[0])}" cy="${n(key.head[1])}" r="${HEAD_R}">${go ? anim('cx', frames.map((f) => n(f.head[0])), def.dur) + anim('cy', frames.map((f) => n(f.head[1])), def.dur) : ''}</circle>`;
+    const back = def.front ? '' : ' stroke-opacity=".4"';
+    const wallX = def.wall ? Math.min(...frames.flatMap((f) => [f.hip[0], f.sh[0]])) - 3.5 : 0;
+    return [
+        '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="100%" height="100%" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true" focusable="false">',
+        `<path d="M6 59H58" stroke="${ACCENT}" stroke-width="2"/>`,
+        def.wall ? `<path d="M${n(wallX)} 10V59" stroke="${ACCENT}" stroke-width="2"/>` : '',
+        path((f) => line(f.legs[0]), back),
+        path((f) => line(f.arms[0]), back),
+        path(spine),
+        head,
+        path((f) => line(f.legs[1])),
+        path((f) => line(f.arms[1])),
+        '</svg>'
+    ].join('');
+}
+// ── Library and matching ──────────────────────────────────────────────────
+/** Lowercase words, no punctuation, no "pose", plurals made singular. */
+export function normalizeExerciseName(name) {
+    return name
+        .toLowerCase()
+        .replace(/['’]/g, '')
+        .replace(/[^a-z0-9]+/g, ' ')
+        .split(' ')
+        .filter((w) => w && w !== 'pose' && w !== 'position')
+        .map((w) => (/(ch|sh|x)es$/.test(w) ? w.slice(0, -2) : w.length > 2 && /[^s]s$/.test(w) ? w.slice(0, -1) : w))
+        .join(' ');
+}
+export const EXERCISE_FIGURES = Object.fromEntries(Object.entries(DEFS).map(([id, def]) => [
+    id,
+    {
+        id,
+        aliases: [...new Set([id, ...def.aliases].map(normalizeExerciseName))],
+        svg: build(def, true),
+        still: build(def, false)
+    }
+]));
+export const FIGURE_IDS = Object.keys(EXERCISE_FIGURES);
+const ALIASES = FIGURE_IDS.flatMap((id) => EXERCISE_FIGURES[id].aliases.map((alias) => ({ id, alias }))).toSorted((a, b) => b.alias.length - a.alias.length);
+/**
+ * The figure id for an exercise: a known explicit id wins, else the longest
+ * alias found as whole words in the name ("Jump squats" picks jump-squat over
+ * squat), else null.
+ */
+export function matchFigure(name, explicit) {
+    if (explicit && Object.hasOwn(EXERCISE_FIGURES, explicit))
+        return explicit;
+    if (typeof name !== 'string')
+        return null;
+    const hay = ` ${normalizeExerciseName(name)} `;
+    return ALIASES.find(({ alias }) => hay.includes(` ${alias} `))?.id ?? null;
+}

package/dist/widgets/composite/habit-tracker.d.ts

@@ -0,0 +1,53 @@
+import { type HabitIconKey } from '../data-kit/icons.js';
+export declare const MAX_HABITS = 8;
+export declare const MAX_WEEKS = 4;
+/** How far back a seed offset may reach, in days. */
+export declare const MAX_SEED_DAYS = 366;
+export type WeekStart = 'mon' | 'sun';
+export interface Habit {
+    id: string;
+    name: string;
+    icon?: HabitIconKey;
+    target_per_week: number;
+}
+export interface HabitValue {
+    habits: Habit[];
+    /** Ticked local days per habit id, ISO `YYYY-MM-DD`, sorted, no repeats. */
+    ticks: Record<string, string[]>;
+}
+export declare const isoDay: (d: Date) => string;
+export declare function fromIso(iso: string): Date;
+export declare function addDays(iso: string, n: number): string;
+export declare function weekStartOf(iso: string, start: WeekStart): string;
+export declare const weekDays: (startIso: string) => string[];
+export declare function currentStreak(ticks: ReadonlySet<string>, today: string): number;
+export declare function longestStreak(ticks: Iterable<string>): number;
+export declare const countIn: (ticks: ReadonlySet<string>, days: readonly string[]) => number;
+/** Met, or still reachable in the days left this week (today included). */
+export declare const onTrack: (done: number, target: number, daysLeft: number) => boolean;
+/** The tracker's first day: its earliest tick across habits, else today. */
+export declare function startDay(ticks: Record<string, readonly string[]>, today: string): string;
+/** A weekly target cut to the week's days on or after `start`: a tracker begun on Friday owes at most 3 days. */
+export declare const targetSince: (target: number, week: readonly string[], start: string) => number;
+export declare const clampTarget: (v: unknown) => number;
+export declare const isHabitIcon: (v: unknown) => v is HabitIconKey;
+/** The first free `hN` id. */
+export declare function nextHabitId(habits: readonly {
+    id: string;
+}[]): string;
+/** Up to 8 named habits with unique ids; id-less ones get `h${index + 1}`. */
+export declare function readHabits(raw: unknown): Habit[];
+/** Valid ISO days for known habit ids only. */
+export declare function readTicks(raw: unknown, habits: readonly Habit[]): Record<string, string[]>;
+/** `seed` offsets (0 = today, 1 = yesterday) as ISO days back from `today`. */
+export declare function seedTicks(seed: unknown, habits: readonly Habit[], today: string): Record<string, string[]>;
+/** A bound or edited value, cleaned; undefined when it carries no habits key. */
+export declare function toValue(raw: unknown): HabitValue | undefined;
+/** A copy of `value` with `day` ticked or unticked for habit `id`. */
+export declare function toggleTick(value: HabitValue, id: string, day: string): HabitValue;
+/** "Tuesday 14 October". English and fixed, so server and client agree. */
+export declare function dayLong(iso: string): string;
+/** "Tue". */
+export declare const dayShort: (iso: string) => string;
+/** "13 to 19 Oct", "29 Sep to 5 Oct". */
+export declare function weekRange(days: readonly string[]): string;

package/dist/widgets/composite/habit-tracker.js

@@ -0,0 +1,149 @@
+// widgets/composite/habit-tracker.ts: the maths behind the habit-tracker
+// widget: local-calendar ISO days, weeks that start on Monday or Sunday,
+// streaks, weekly targets, and the normaliser that turns model props (or a
+// bound value) into a clean HabitValue.
+//
+// Invariants:
+// - A day is a local-calendar `YYYY-MM-DD` built from getFullYear/getMonth/
+//   getDate, never toISOString (that is UTC and shifts the day near midnight).
+// - A streak counts consecutive ticked days ending today; an unticked today
+//   does not break it yet (it ends yesterday instead).
+// - No storage: the value lives in props and widget state only.
+import { finite, plain } from '../data-kit/format.js';
+import { HABIT_ICONS } from '../data-kit/icons.js';
+import { list, rec } from './recipe.js';
+export const MAX_HABITS = 8;
+export const MAX_WEEKS = 4;
+/** How far back a seed offset may reach, in days. */
+export const MAX_SEED_DAYS = 366;
+const ISO = /^\d{4}-\d{2}-\d{2}$/;
+const pad = (n) => String(n).padStart(2, '0');
+export const isoDay = (d) => `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+export function fromIso(iso) {
+    const [y, m, d] = iso.split('-').map(Number);
+    return new Date(y, m - 1, d);
+}
+export function addDays(iso, n) {
+    const d = fromIso(iso);
+    d.setDate(d.getDate() + n);
+    return isoDay(d);
+}
+export function weekStartOf(iso, start) {
+    const dow = fromIso(iso).getDay();
+    return addDays(iso, -(start === 'sun' ? dow : (dow + 6) % 7));
+}
+export const weekDays = (startIso) => Array.from({ length: 7 }, (_, i) => addDays(startIso, i));
+export function currentStreak(ticks, today) {
+    let d = ticks.has(today) ? today : addDays(today, -1);
+    let n = 0;
+    while (ticks.has(d)) {
+        n++;
+        d = addDays(d, -1);
+    }
+    return n;
+}
+export function longestStreak(ticks) {
+    let best = 0;
+    let run = 0;
+    let prev = '';
+    for (const d of [...new Set(ticks)].sort()) {
+        run = prev && addDays(prev, 1) === d ? run + 1 : 1;
+        best = Math.max(best, run);
+        prev = d;
+    }
+    return best;
+}
+export const countIn = (ticks, days) => days.filter((d) => ticks.has(d)).length;
+/** Met, or still reachable in the days left this week (today included). */
+export const onTrack = (done, target, daysLeft) => done >= target || target - done <= daysLeft;
+/** The tracker's first day: its earliest tick across habits, else today. */
+export function startDay(ticks, today) {
+    let first = today;
+    for (const days of Object.values(ticks))
+        if (days[0] && days[0] < first)
+            first = days[0];
+    return first;
+}
+/** A weekly target cut to the week's days on or after `start`: a tracker begun on Friday owes at most 3 days. */
+export const targetSince = (target, week, start) => Math.min(target, week.filter((d) => d >= start).length);
+export const clampTarget = (v) => {
+    const n = finite(v);
+    return n === undefined ? 7 : Math.min(Math.max(Math.round(n), 1), 7);
+};
+export const isHabitIcon = (v) => typeof v === 'string' && Object.hasOwn(HABIT_ICONS, v);
+/** The first free `hN` id. */
+export function nextHabitId(habits) {
+    const used = new Set(habits.map((h) => h.id));
+    let n = habits.length + 1;
+    while (used.has(`h${n}`))
+        n++;
+    return `h${n}`;
+}
+/** Up to 8 named habits with unique ids; id-less ones get `h${index + 1}`. */
+export function readHabits(raw) {
+    const out = [];
+    const ids = new Set();
+    list(raw).forEach((r, i) => {
+        if (out.length >= MAX_HABITS)
+            return;
+        const h = typeof r === 'string' ? { name: r } : rec(r);
+        const name = plain(h.name).slice(0, 60);
+        if (!name)
+            return;
+        let id = typeof h.id === 'string' || typeof h.id === 'number' ? String(h.id).trim() : '';
+        if (!id)
+            id = `h${i + 1}`;
+        if (ids.has(id))
+            id = `${id}-${i}`;
+        ids.add(id);
+        out.push({ id, name, ...(isHabitIcon(h.icon) ? { icon: h.icon } : {}), target_per_week: clampTarget(h.target_per_week) });
+    });
+    return out;
+}
+const cleanDays = (days) => [...new Set([...days].filter((d) => typeof d === 'string' && ISO.test(d) && isoDay(fromIso(d)) === d))].sort();
+/** Valid ISO days for known habit ids only. */
+export function readTicks(raw, habits) {
+    const r = rec(raw);
+    return Object.fromEntries(habits.map((h) => [h.id, cleanDays(list(r[h.id]))]));
+}
+/** `seed` offsets (0 = today, 1 = yesterday) as ISO days back from `today`. */
+export function seedTicks(seed, habits, today) {
+    const r = rec(seed);
+    return Object.fromEntries(habits.map((h) => [
+        h.id,
+        cleanDays(list(r[h.id]).flatMap((v) => {
+            const n = finite(v);
+            return n === undefined || n < 0 || n > MAX_SEED_DAYS ? [] : [addDays(today, -Math.round(n))];
+        }))
+    ]));
+}
+/** A bound or edited value, cleaned; undefined when it carries no habits key. */
+export function toValue(raw) {
+    const r = rec(raw);
+    if (!Array.isArray(r.habits))
+        return undefined;
+    const habits = readHabits(r.habits);
+    return { habits, ticks: readTicks(r.ticks, habits) };
+}
+/** A copy of `value` with `day` ticked or unticked for habit `id`. */
+export function toggleTick(value, id, day) {
+    const days = value.ticks[id] ?? [];
+    const next = days.includes(day) ? days.filter((d) => d !== day) : cleanDays([...days, day]);
+    return { ...value, ticks: { ...value.ticks, [id]: next } };
+}
+const WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+const MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+/** "Tuesday 14 October". English and fixed, so server and client agree. */
+export function dayLong(iso) {
+    const d = fromIso(iso);
+    return `${WEEKDAYS[d.getDay()]} ${d.getDate()} ${MONTHS[d.getMonth()]}`;
+}
+/** "Tue". */
+export const dayShort = (iso) => WEEKDAYS[fromIso(iso).getDay()].slice(0, 3);
+/** "13 to 19 Oct", "29 Sep to 5 Oct". */
+export function weekRange(days) {
+    const a = fromIso(days[0]);
+    const b = fromIso(days[6]);
+    const m = (d) => MONTHS[d.getMonth()].slice(0, 3);
+    return a.getMonth() === b.getMonth() ? `${a.getDate()} to ${b.getDate()} ${m(b)}` : `${a.getDate()} ${m(a)} to ${b.getDate()} ${m(b)}`;
+}