@opencode/util 0.0.0-reserved → 2.0.1

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/dist/binary.d.ts

@@ -0,0 +1,7 @@
+export declare namespace Binary {
+    function search<T>(array: T[], id: string, compare: (item: T) => string): {
+        found: boolean;
+        index: number;
+    };
+    function insert<T>(array: T[], item: T, compare: (item: T) => string): T[];
+}

package/dist/binary.js

@@ -0,0 +1,34 @@
+export var Binary;
+(function (Binary) {
+    function search(array, id, compare) {
+        let left = 0;
+        let right = array.length - 1;
+        while (left <= right) {
+            const middle = Math.floor((left + right) / 2);
+            const value = compare(array[middle]);
+            if (value === id)
+                return { found: true, index: middle };
+            if (value < id)
+                left = middle + 1;
+            else
+                right = middle - 1;
+        }
+        return { found: false, index: left };
+    }
+    Binary.search = search;
+    function insert(array, item, compare) {
+        const id = compare(item);
+        let left = 0;
+        let right = array.length;
+        while (left < right) {
+            const middle = Math.floor((left + right) / 2);
+            if (compare(array[middle]) < id)
+                left = middle + 1;
+            else
+                right = middle;
+        }
+        array.splice(left, 0, item);
+        return array;
+    }
+    Binary.insert = insert;
+})(Binary || (Binary = {}));

package/dist/binary.test.d.ts

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

package/dist/binary.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test";
+import { Binary } from "./binary.js";
+describe("binary search", () => {
+    test("finds sorted values and their insertion points", () => {
+        const values = [{ id: "a" }, { id: "c" }, { id: "e" }];
+        expect(Binary.search(values, "c", (item) => item.id)).toEqual({ found: true, index: 1 });
+        expect(Binary.search(values, "d", (item) => item.id)).toEqual({ found: false, index: 2 });
+        expect(Binary.search(values, "0", (item) => item.id)).toEqual({ found: false, index: 0 });
+    });
+    test("inserts before the first matching sorted value", () => {
+        const values = [{ id: "a" }, { id: "c" }, { id: "c" }, { id: "e" }];
+        const item = { id: "c" };
+        expect(Binary.insert(values, item, (value) => value.id)).toBe(values);
+        expect(values).toEqual([{ id: "a" }, item, { id: "c" }, { id: "c" }, { id: "e" }]);
+    });
+});

package/dist/bom.d.ts

@@ -0,0 +1,22 @@
+export * as Bom from "./bom.js";
+import { Effect } from "effect";
+import type { FSUtil } from "./fs-util.js";
+export declare function split(text: string): {
+    bom: boolean;
+    text: string;
+};
+export declare function join(text: string, bom: boolean): string;
+export declare function has(content: Uint8Array): boolean;
+export declare function decodeBytes(content: Uint8Array): {
+    bom: boolean;
+    text: string;
+};
+export declare function syncBytes(content: Uint8Array, bom: boolean): {
+    text: string;
+    bytes: Uint8Array<ArrayBufferLike> | undefined;
+};
+export declare const readFile: (fs: FSUtil.Interface, filepath: string) => Effect.Effect<{
+    bom: boolean;
+    text: string;
+}, import("effect/PlatformError").PlatformError, never>;
+export declare const syncFile: (fs: FSUtil.Interface, filepath: string, bom: boolean) => Effect.Effect<string, FSUtil.Error, never>;

package/dist/bom.js

@@ -0,0 +1,36 @@
+export * as Bom from "./bom.js";
+import { Effect } from "effect";
+const code = 0xfeff;
+const value = String.fromCharCode(code);
+export function split(text) {
+    const stripped = text.replace(/^\uFEFF+/, "");
+    return { bom: stripped.length !== text.length, text: stripped };
+}
+export function join(text, bom) {
+    const stripped = split(text).text;
+    return bom ? value + stripped : stripped;
+}
+export function has(content) {
+    return content[0] === 0xef && content[1] === 0xbb && content[2] === 0xbf;
+}
+export function decodeBytes(content) {
+    return split(decode(content));
+}
+export function syncBytes(content, bom) {
+    const decoded = decode(content);
+    const current = split(decoded);
+    const canonical = bom ? value + current.text : current.text;
+    return { text: current.text, bytes: decoded === canonical ? undefined : new TextEncoder().encode(canonical) };
+}
+export const readFile = Effect.fn("Bom.readFile")(function* (fs, filepath) {
+    return decodeBytes(yield* fs.readFile(filepath));
+});
+export const syncFile = Effect.fn("Bom.syncFile")(function* (fs, filepath, bom) {
+    const synced = syncBytes(yield* fs.readFile(filepath), bom);
+    if (synced.bytes)
+        yield* fs.writeWithDirs(filepath, synced.bytes);
+    return synced.text;
+});
+function decode(content) {
+    return new TextDecoder("utf-8", { ignoreBOM: true }).decode(content);
+}

package/dist/bom.test.d.ts

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

package/dist/bom.test.js

@@ -0,0 +1,19 @@
+import { expect, test } from "bun:test";
+import { Bom } from "./bom.js";
+test.each([
+    { prefix: "", bom: false, expected: undefined },
+    { prefix: "", bom: true, expected: "\uFEFF" },
+    { prefix: "\uFEFF", bom: false, expected: "" },
+    { prefix: "\uFEFF", bom: true, expected: undefined },
+    { prefix: "\uFEFF\uFEFF", bom: false, expected: "" },
+    { prefix: "\uFEFF\uFEFF", bom: true, expected: "\uFEFF" },
+])("syncBytes(%j)", (row) => {
+    const encoder = new TextEncoder();
+    const text = "a\uFEFF\u00e9";
+    const input = encoder.encode(row.prefix + text);
+    expect(Bom.syncBytes(input, row.bom)).toEqual({
+        text,
+        bytes: row.expected === undefined ? undefined : encoder.encode(row.expected + text),
+    });
+    expect(input).toEqual(encoder.encode(row.prefix + text));
+});

package/dist/cross-spawn-spawner.d.ts

@@ -0,0 +1,3 @@
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+export declare const node: import("./effect/layer-node.js").Provider<ChildProcessSpawner, never, import("./effect/layer-node.js").Tag<"global">>;
+export * as CrossSpawnSpawner from "./cross-spawn-spawner.js";