@opencode-ai/util 0.0.0-dev-17582 → 0.0.0-dev-17604

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

@@ -0,0 +1,4 @@
+export declare function base64Encode(value: string): string;
+export declare function base64Decode(value: string): string;
+export declare function checksum(content: string): string | undefined;
+export declare function sampledChecksum(content: string, limit?: number): string | undefined;

package/dist/encode.js

@@ -0,0 +1,38 @@
+export function base64Encode(value) {
+    const bytes = new TextEncoder().encode(value);
+    const binary = Array.from(bytes, (byte) => String.fromCharCode(byte)).join("");
+    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+export function base64Decode(value) {
+    const binary = atob(value.replace(/-/g, "+").replace(/_/g, "/"));
+    return new TextDecoder().decode(Uint8Array.from(binary, (character) => character.charCodeAt(0)));
+}
+export function checksum(content) {
+    if (!content)
+        return;
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < content.length; index++) {
+        hash ^= content.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(36);
+}
+export function sampledChecksum(content, limit = 500_000) {
+    if (!content)
+        return;
+    if (content.length <= limit)
+        return checksum(content);
+    const size = 4096;
+    return `${content.length}:${[
+        0,
+        Math.floor(content.length * 0.25),
+        Math.floor(content.length * 0.5),
+        Math.floor(content.length * 0.75),
+        content.length - size,
+    ]
+        .map((point) => {
+        const start = Math.max(0, Math.min(content.length - size, point - Math.floor(size / 2)));
+        return checksum(content.slice(start, start + size)) ?? "";
+    })
+        .join(":")}`;
+}

package/dist/encode.test.d.ts

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

package/dist/encode.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, test } from "bun:test";
+import { base64Decode, base64Encode, checksum, sampledChecksum } from "./encode.js";
+describe("frontend encoding", () => {
+    test("uses unpadded URL-safe UTF-8 base64", () => {
+        expect(base64Encode("hello")).toBe("aGVsbG8");
+        expect(base64Encode("✓ à la mode")).toBe("4pyTIMOgIGxhIG1vZGU");
+        expect(base64Decode("4pyTIMOgIGxhIG1vZGU")).toBe("✓ à la mode");
+        expect(base64Decode("dXNlcjpwYXNz")).toBe("user:pass");
+    });
+    test("rejects invalid base64", () => {
+        expect(() => base64Decode("%%%")).toThrow();
+    });
+    test("keeps stable FNV checksums", () => {
+        expect(checksum("")).toBeUndefined();
+        expect(checksum("hello")).toBe("m3bicr");
+        expect(checksum("✓ à la mode")).toBe("jmczk0");
+    });
+    test("samples large values without changing the size boundary", () => {
+        const value = "abcdef".repeat(100);
+        expect(sampledChecksum(value, value.length)).toBe(checksum(value));
+        expect(sampledChecksum(value, value.length - 1)).toBe("600:1isj1k5:1isj1k5:1isj1k5:1isj1k5:1isj1k5");
+    });
+});

package/dist/path.d.ts

@@ -0,0 +1,4 @@
+export declare function getFilename(path: string | undefined): string;
+export declare function getDirectory(path: string | undefined): string;
+export declare function getFilenameTruncated(path: string | undefined, maxLength?: number): string;
+export declare function truncateMiddle(text: string, maxLength?: number): string;

package/dist/path.js

@@ -0,0 +1,33 @@
+export function getFilename(path) {
+    if (!path)
+        return "";
+    const trimmed = path.replace(/[/\\]+$/, "");
+    const parts = trimmed.split(/[/\\]/);
+    return parts[parts.length - 1] ?? "";
+}
+export function getDirectory(path) {
+    if (!path)
+        return "";
+    const trimmed = path.replace(/[/\\]+$/, "");
+    const parts = trimmed.split(/[/\\]/);
+    return parts.slice(0, parts.length - 1).join("/") + "/";
+}
+export function getFilenameTruncated(path, maxLength = 20) {
+    const filename = getFilename(path);
+    if (filename.length <= maxLength)
+        return filename;
+    const lastDot = filename.lastIndexOf(".");
+    const extension = lastDot <= 0 ? "" : filename.slice(lastDot);
+    const available = maxLength - extension.length - 1;
+    if (available <= 0)
+        return filename.slice(0, maxLength - 1) + "…";
+    return filename.slice(0, available) + "…" + extension;
+}
+export function truncateMiddle(text, maxLength = 20) {
+    if (text.length <= maxLength)
+        return text;
+    const available = maxLength - 1;
+    const start = Math.ceil(available / 2);
+    const end = Math.floor(available / 2);
+    return text.slice(0, start) + "…" + text.slice(-end);
+}

package/dist/path.test.d.ts

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

package/dist/path.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, test } from "bun:test";
+import { getDirectory, getFilename, getFilenameTruncated, truncateMiddle } from "./path.js";
+describe("client paths", () => {
+    test("reads POSIX and Windows paths with the same rules", () => {
+        expect(getFilename("/repo/src/index.ts")).toBe("index.ts");
+        expect(getFilename("C:\\repo\\src\\index.ts\\")).toBe("index.ts");
+        expect(getDirectory("/repo/src/index.ts")).toBe("/repo/src/");
+        expect(getDirectory("C:\\repo\\src\\index.ts")).toBe("C:/repo/src/");
+    });
+    test("preserves root, UNC, mixed, and single-segment behavior", () => {
+        expect(getFilename("\\\\server\\share\\file")).toBe("file");
+        expect(getDirectory("\\\\server\\share\\file")).toBe("//server/share/");
+        expect(getDirectory("C:\\repo/src\\file")).toBe("C:/repo/src/");
+        expect(getDirectory("file")).toBe("/");
+        expect(getFilename(undefined)).toBe("");
+        expect(getDirectory("")).toBe("");
+    });
+    test("keeps filename truncation stable", () => {
+        expect(getFilenameTruncated("/repo/long-component-name.tsx", 16)).toBe("long-compon….tsx");
+        expect(truncateMiddle("abcdefghijklmnop", 9)).toBe("abcd…mnop");
+    });
+});

package/dist/retry.d.ts

@@ -0,0 +1,8 @@
+export interface RetryOptions {
+    attempts?: number;
+    delay?: number;
+    factor?: number;
+    maxDelay?: number;
+    retryIf?: (error: unknown) => boolean;
+}
+export declare function retry<T>(operation: () => Promise<T>, options?: RetryOptions): Promise<T>;

package/dist/retry.js

@@ -0,0 +1,37 @@
+const transientMessages = [
+    "load failed",
+    "network connection was lost",
+    "network request failed",
+    "failed to fetch",
+    "econnreset",
+    "econnrefused",
+    "etimedout",
+    "socket hang up",
+];
+function isTransientError(error) {
+    if (!error)
+        return false;
+    // oxlint-disable-next-line no-base-to-string -- Error input is intentionally normalized for message matching.
+    const message = String(error instanceof Error ? error.message : error).toLowerCase();
+    return transientMessages.some((item) => message.includes(item));
+}
+export async function retry(operation, options = {}) {
+    const attempts = options.attempts ?? 3;
+    const delay = options.delay ?? 500;
+    const factor = options.factor ?? 2;
+    const maxDelay = options.maxDelay ?? 10_000;
+    const retryIf = options.retryIf ?? isTransientError;
+    let lastError;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === attempts - 1 || !retryIf(error))
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, Math.min(delay * Math.pow(factor, attempt), maxDelay)));
+        }
+    }
+    throw lastError;
+}

package/dist/retry.test.d.ts

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

package/dist/retry.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import { retry } from "./retry.js";
+describe("client retry", () => {
+    test("retries transient failures up to the configured attempt count", async () => {
+        const failures = [];
+        const value = await retry(async () => {
+            failures.push("attempt");
+            if (failures.length < 3)
+                throw new Error("Failed to fetch");
+            return "ready";
+        }, { delay: 0 });
+        expect(value).toBe("ready");
+        expect(failures).toHaveLength(3);
+    });
+    test("does not retry other failures", async () => {
+        const failures = [];
+        await expect(retry(async () => {
+            failures.push("attempt");
+            throw new Error("invalid response");
+        })).rejects.toThrow("invalid response");
+        expect(failures).toHaveLength(1);
+    });
+    test("uses a caller-owned retry condition", async () => {
+        const failures = [];
+        await expect(retry(async () => {
+            failures.push("attempt");
+            throw new Error("retry me");
+        }, { attempts: 2, delay: 0, retryIf: () => true })).rejects.toThrow("retry me");
+        expect(failures).toHaveLength(2);
+    });
+});

package/package.json

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