@opencode-ai/util 0.0.0-dev-18819 → 0.0.0-dev-18822

package/dist/activity-calendar.d.ts

@@ -0,0 +1,21 @@
+export declare function activityCalendar(input: {
+    activity: readonly {
+        date: string;
+        steps: number;
+    }[];
+    from: number;
+    to: number;
+    maxWeeks: number;
+}): {
+    weeks: {
+        date: string;
+        steps: number;
+        level: number;
+    }[][];
+    months: {
+        span: number;
+        week: number;
+        label: string;
+    }[];
+    clipped: boolean;
+};

package/dist/activity-calendar.js

@@ -0,0 +1,42 @@
+export function activityCalendar(input) {
+    // Extract local dates first, then use UTC ordinals so DST cannot add or drop cells.
+    const ordinal = (time) => {
+        const date = new Date(time);
+        return Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()) / 86_400_000;
+    };
+    const from = ordinal(input.from);
+    const to = ordinal(input.to - 1);
+    const monday = from - ((new Date(from * 86_400_000).getUTCDay() + 6) % 7);
+    const total = input.to <= input.from ? 0 : Math.floor((to - monday) / 7) + 1;
+    const count = Math.min(total, 53, Math.max(1, Math.floor(input.maxWeeks)));
+    const start = monday + Math.max(0, total - count) * 7;
+    const values = new Map(input.activity.map((day) => [day.date, day.steps]));
+    const levels = [...new Set([...values.values()].filter((steps) => steps > 0))].sort((a, b) => a - b);
+    const weeks = Array.from({ length: count }, (_, week) => Array.from({ length: 7 }, (_, day) => {
+        const date = start + week * 7 + day;
+        const key = new Date(date * 86_400_000).toISOString().slice(0, 10);
+        const steps = values.get(key) ?? 0;
+        return {
+            date: key,
+            steps,
+            level: date < from || date > to
+                ? -1
+                : steps === 0
+                    ? 0
+                    : Math.max(1, Math.ceil(((levels.indexOf(steps) + 1) / levels.length) * 4)),
+        };
+    }));
+    const formatter = new Intl.DateTimeFormat("en-US", { month: "short", timeZone: "UTC" });
+    // Thursday identifies the month owning most of a week; partial edge weeks stay inside the range.
+    const months = weeks
+        .map((_, week) => ({
+        week,
+        label: formatter.format(Math.min(to, Math.max(from, start + week * 7 + 3)) * 86_400_000),
+    }))
+        .filter((month, index, months) => index === 0 || month.label !== months[index - 1].label);
+    return {
+        weeks,
+        months: months.map((month, index) => ({ ...month, span: (months[index + 1]?.week ?? count) - month.week })),
+        clipped: count < total,
+    };
+}

package/dist/activity-calendar.test.d.ts

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

package/dist/activity-calendar.test.js

@@ -0,0 +1,119 @@
+import { describe, expect, test } from "bun:test";
+import { activityCalendar } from "./activity-calendar.js";
+const input = {
+    from: new Date(2026, 0, 1).getTime(),
+    to: new Date(2026, 0, 8).getTime(),
+    maxWeeks: 53,
+    activity: [
+        { date: "2026-01-01", steps: 1 },
+        { date: "2026-01-02", steps: 50 },
+    ],
+};
+describe("activity calendar", () => {
+    test("aligns Monday-first weeks and excludes cells outside the end-exclusive range", () => {
+        const calendar = activityCalendar(input);
+        expect(calendar.clipped).toBe(false);
+        expect(calendar.weeks).toHaveLength(2);
+        expect(calendar.weeks[0][0]).toEqual({ date: "2025-12-29", steps: 0, level: -1 });
+        expect(calendar.weeks[0][3]).toEqual({ date: "2026-01-01", steps: 1, level: 2 });
+        expect(calendar.weeks[0][4]).toEqual({ date: "2026-01-02", steps: 50, level: 4 });
+        expect(calendar.weeks[1][2]).toEqual({ date: "2026-01-07", steps: 0, level: 0 });
+        expect(calendar.weeks[1][3].level).toBe(-1);
+        expect(calendar.months).toEqual([{ week: 0, label: "Jan", span: 2 }]);
+    });
+    test("clips to the latest weeks and keeps empty days distinct from out-of-range cells", () => {
+        const calendar = activityCalendar({ ...input, activity: [], maxWeeks: 1 });
+        expect(calendar.clipped).toBe(true);
+        expect(calendar.weeks).toHaveLength(1);
+        expect(calendar.weeks[0][0]).toEqual({ date: "2026-01-05", steps: 0, level: 0 });
+        expect(calendar.weeks[0][3].level).toBe(-1);
+    });
+    test("caps long histories at 53 weeks", () => {
+        const calendar = activityCalendar({ ...input, from: new Date(2020, 0, 1).getTime(), maxWeeks: 200 });
+        expect(calendar.clipped).toBe(true);
+        expect(calendar.weeks).toHaveLength(53);
+        expect(calendar.weeks.at(-1)?.[2].date).toBe("2026-01-07");
+        expect(calendar.months.reduce((sum, month) => sum + month.span, 0)).toBe(53);
+    });
+    test("returns month positions and spans for partial first and last months", () => {
+        const calendar = activityCalendar({
+            ...input,
+            from: new Date(2026, 3, 29).getTime(),
+            to: new Date(2026, 4, 20).getTime(),
+        });
+        expect(calendar.months).toEqual([
+            { week: 0, label: "Apr", span: 1 },
+            { week: 1, label: "May", span: 3 },
+        ]);
+        const partial = activityCalendar({
+            ...input,
+            from: new Date(2026, 3, 1).getTime(),
+            to: new Date(2026, 3, 2).getTime(),
+        });
+        expect(partial.months).toEqual([{ week: 0, label: "Apr", span: 1 }]);
+    });
+    test("places month labels across a year boundary", () => {
+        const calendar = activityCalendar({
+            ...input,
+            from: new Date(2025, 11, 22).getTime(),
+            to: new Date(2026, 0, 12).getTime(),
+        });
+        expect(calendar.months).toEqual([
+            { week: 0, label: "Dec", span: 1 },
+            { week: 1, label: "Jan", span: 2 },
+        ]);
+    });
+    test("keeps exactly seven distinct cells per week across DST and leap days", () => {
+        const calendar = activityCalendar({
+            from: new Date(2024, 1, 26).getTime(),
+            to: new Date(2024, 2, 12).getTime(),
+            maxWeeks: 53,
+            activity: [
+                { date: "2024-02-29", steps: 1 },
+                { date: "2024-03-10", steps: 1 },
+            ],
+        });
+        expect(calendar.weeks).toHaveLength(3);
+        expect(calendar.weeks
+            .flat()
+            .filter((day) => day.steps > 0)
+            .map((day) => day.date)).toEqual(["2024-02-29", "2024-03-10"]);
+        expect(new Set(calendar.weeks.flat().map((day) => day.date)).size).toBe(21);
+    });
+    test("uses the highest intensity for a single distinct positive count", () => {
+        const calendar = activityCalendar({ ...input, activity: input.activity.map((day) => ({ ...day, steps: 10 })) });
+        expect(calendar.weeks
+            .flat()
+            .filter((day) => day.steps > 0)
+            .map((day) => day.level)).toEqual([4, 4]);
+    });
+    test("ranks distinct activity counts in four levels", () => {
+        const calendar = activityCalendar({
+            ...input,
+            to: new Date(2026, 0, 10).getTime(),
+            activity: Array.from({ length: 8 }, (_, index) => ({ date: `2026-01-0${index + 1}`, steps: index + 1 })),
+        });
+        expect(calendar.weeks
+            .flat()
+            .filter((day) => day.steps > 0)
+            .map((day) => day.level)).toEqual([1, 1, 2, 2, 3, 3, 4, 4]);
+    });
+    test("keeps intensity relative to the requested range when older weeks are clipped", () => {
+        const calendar = activityCalendar({
+            ...input,
+            maxWeeks: 1,
+            activity: [
+                { date: "2026-01-01", steps: 50 },
+                { date: "2026-01-05", steps: 1 },
+            ],
+        });
+        expect(calendar.weeks[0][0].level).toBe(2);
+    });
+    test("returns an empty calendar for an empty range", () => {
+        expect(activityCalendar({ ...input, to: input.from, activity: [] })).toEqual({
+            weeks: [],
+            months: [],
+            clipped: false,
+        });
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/util",
-  "version": "0.0.0-dev-18819",
+  "version": "0.0.0-dev-18822",
   "type": "module",
   "license": "MIT",
   "repository": {