@stackframe/stack-shared 2.7.19 → 2.7.21

package/dist/utils/results.js

@@ -1,4 +1,3 @@
-import { wait } from "./promises";
 import { deindent } from "./strings";
 export const Result = {
     fromThrowing,
@@ -21,8 +20,9 @@ export const Result = {
         return result.status === "ok" ? result.data : fallback;
     },
     orThrow: (result) => {
-        if (result.status === "error")
+        if (result.status === "error") {
             throw result.error;
+        }
         return result.data;
     },
     orThrowAsync: async (result) => {
@@ -30,6 +30,43 @@ export const Result = {
     },
     retry,
 };
+import.meta.vitest?.test("Result.ok and Result.error", ({ expect }) => {
+    // Test Result.ok
+    const okResult = Result.ok(42);
+    expect(okResult.status).toBe("ok");
+    expect(okResult.data).toBe(42);
+    // Test Result.error
+    const error = new Error("Test error");
+    const errorResult = Result.error(error);
+    expect(errorResult.status).toBe("error");
+    expect(errorResult.error).toBe(error);
+});
+import.meta.vitest?.test("Result.or", ({ expect }) => {
+    // Test with ok result
+    const okResult = { status: "ok", data: 42 };
+    expect(Result.or(okResult, 0)).toBe(42);
+    // Test with error result
+    const errorResult = { status: "error", error: "error message" };
+    expect(Result.or(errorResult, 0)).toBe(0);
+});
+import.meta.vitest?.test("Result.orThrow", ({ expect }) => {
+    // Test with ok result
+    const okResult = { status: "ok", data: 42 };
+    expect(Result.orThrow(okResult)).toBe(42);
+    // Test with error result
+    const error = new Error("Test error");
+    const errorResult = { status: "error", error };
+    expect(() => Result.orThrow(errorResult)).toThrow(error);
+});
+import.meta.vitest?.test("Result.orThrowAsync", async ({ expect }) => {
+    // Test with ok result
+    const okPromise = Promise.resolve({ status: "ok", data: 42 });
+    expect(await Result.orThrowAsync(okPromise)).toBe(42);
+    // Test with error result
+    const error = new Error("Test error");
+    const errorPromise = Promise.resolve({ status: "error", error });
+    await expect(Result.orThrowAsync(errorPromise)).rejects.toThrow(error);
+});
 export const AsyncResult = {
     fromThrowing,
     fromPromise: promiseToResult,
@@ -38,23 +75,59 @@ export const AsyncResult = {
     pending,
     map: mapResult,
     or: (result, fallback) => {
-        if (result.status === "pending")
+        if (result.status === "pending") {
             return fallback;
+        }
         return Result.or(result, fallback);
     },
     orThrow: (result) => {
-        if (result.status === "pending")
+        if (result.status === "pending") {
             throw new Error("Result still pending");
+        }
         return Result.orThrow(result);
     },
     retry,
 };
+import.meta.vitest?.test("AsyncResult.or", ({ expect }) => {
+    // Test with ok result
+    const okResult = { status: "ok", data: 42 };
+    expect(AsyncResult.or(okResult, 0)).toBe(42);
+    // Test with error result
+    const errorResult = { status: "error", error: "error message" };
+    expect(AsyncResult.or(errorResult, 0)).toBe(0);
+    // Test with pending result
+    const pendingResult = { status: "pending", progress: undefined };
+    expect(AsyncResult.or(pendingResult, 0)).toBe(0);
+});
+import.meta.vitest?.test("AsyncResult.orThrow", ({ expect }) => {
+    // Test with ok result
+    const okResult = { status: "ok", data: 42 };
+    expect(AsyncResult.orThrow(okResult)).toBe(42);
+    // Test with error result
+    const error = new Error("Test error");
+    const errorResult = { status: "error", error };
+    expect(() => AsyncResult.orThrow(errorResult)).toThrow(error);
+    // Test with pending result
+    const pendingResult = { status: "pending", progress: undefined };
+    expect(() => AsyncResult.orThrow(pendingResult)).toThrow("Result still pending");
+});
 function pending(progress) {
     return {
         status: "pending",
         progress: progress,
     };
 }
+import.meta.vitest?.test("pending", ({ expect }) => {
+    // Test without progress
+    const pendingResult = pending();
+    expect(pendingResult.status).toBe("pending");
+    expect(pendingResult.progress).toBe(undefined);
+    // Test with progress
+    const progressValue = { loaded: 50, total: 100 };
+    const pendingWithProgress = pending(progressValue);
+    expect(pendingWithProgress.status).toBe("pending");
+    expect(pendingWithProgress.progress).toBe(progressValue);
+});
 async function promiseToResult(promise) {
     try {
         const value = await promise;
@@ -64,6 +137,23 @@ async function promiseToResult(promise) {
         return Result.error(error);
     }
 }
+import.meta.vitest?.test("promiseToResult", async ({ expect }) => {
+    // Test with resolved promise
+    const resolvedPromise = Promise.resolve(42);
+    const resolvedResult = await promiseToResult(resolvedPromise);
+    expect(resolvedResult.status).toBe("ok");
+    if (resolvedResult.status === "ok") {
+        expect(resolvedResult.data).toBe(42);
+    }
+    // Test with rejected promise
+    const error = new Error("Test error");
+    const rejectedPromise = Promise.reject(error);
+    const rejectedResult = await promiseToResult(rejectedPromise);
+    expect(rejectedResult.status).toBe("error");
+    if (rejectedResult.status === "error") {
+        expect(rejectedResult.error).toBe(error);
+    }
+});
 function fromThrowing(fn) {
     try {
         return Result.ok(fn());
@@ -72,6 +162,25 @@ function fromThrowing(fn) {
         return Result.error(error);
     }
 }
+import.meta.vitest?.test("fromThrowing", ({ expect }) => {
+    // Test with function that succeeds
+    const successFn = () => 42;
+    const successResult = fromThrowing(successFn);
+    expect(successResult.status).toBe("ok");
+    if (successResult.status === "ok") {
+        expect(successResult.data).toBe(42);
+    }
+    // Test with function that throws
+    const error = new Error("Test error");
+    const errorFn = () => {
+        throw error;
+    };
+    const errorResult = fromThrowing(errorFn);
+    expect(errorResult.status).toBe("error");
+    if (errorResult.status === "error") {
+        expect(errorResult.error).toBe(error);
+    }
+});
 async function fromThrowingAsync(fn) {
     try {
         return Result.ok(await fn());
@@ -80,6 +189,25 @@ async function fromThrowingAsync(fn) {
         return Result.error(error);
     }
 }
+import.meta.vitest?.test("fromThrowingAsync", async ({ expect }) => {
+    // Test with async function that succeeds
+    const successFn = async () => 42;
+    const successResult = await fromThrowingAsync(successFn);
+    expect(successResult.status).toBe("ok");
+    if (successResult.status === "ok") {
+        expect(successResult.data).toBe(42);
+    }
+    // Test with async function that throws
+    const error = new Error("Test error");
+    const errorFn = async () => {
+        throw error;
+    };
+    const errorResult = await fromThrowingAsync(errorFn);
+    expect(errorResult.status).toBe("error");
+    if (errorResult.status === "error") {
+        expect(errorResult.error).toBe(error);
+    }
+});
 function mapResult(result, fn) {
     if (result.status === "error")
         return {
@@ -93,6 +221,37 @@ function mapResult(result, fn) {
         };
     return Result.ok(fn(result.data));
 }
+import.meta.vitest?.test("mapResult", ({ expect }) => {
+    // Test with ok result
+    const okResult = { status: "ok", data: 42 };
+    const mappedOk = mapResult(okResult, (n) => n * 2);
+    expect(mappedOk.status).toBe("ok");
+    if (mappedOk.status === "ok") {
+        expect(mappedOk.data).toBe(84);
+    }
+    // Test with error result
+    const errorResult = { status: "error", error: "error message" };
+    const mappedError = mapResult(errorResult, (n) => n * 2);
+    expect(mappedError.status).toBe("error");
+    if (mappedError.status === "error") {
+        expect(mappedError.error).toBe("error message");
+    }
+    // Test with pending result (no progress)
+    const pendingResult = { status: "pending", progress: undefined };
+    const mappedPending = mapResult(pendingResult, (n) => n * 2);
+    expect(mappedPending.status).toBe("pending");
+    // Test with pending result (with progress)
+    const progressValue = { loaded: 50, total: 100 };
+    const pendingWithProgress = {
+        status: "pending",
+        progress: progressValue
+    };
+    const mappedPendingWithProgress = mapResult(pendingWithProgress, (n) => n * 2);
+    expect(mappedPendingWithProgress.status).toBe("pending");
+    if (mappedPendingWithProgress.status === "pending") {
+        expect(mappedPendingWithProgress.progress).toBe(progressValue);
+    }
+});
 class RetryError extends AggregateError {
     constructor(errors) {
         const strings = errors.map(e => String(e));
@@ -116,6 +275,36 @@ class RetryError extends AggregateError {
     }
 }
 RetryError.prototype.name = "RetryError";
+import.meta.vitest?.test("RetryError", ({ expect }) => {
+    // Test with single error
+    const singleError = new Error("Single error");
+    const retryErrorSingle = new RetryError([singleError]);
+    expect(retryErrorSingle.name).toBe("RetryError");
+    expect(retryErrorSingle.errors).toEqual([singleError]);
+    expect(retryErrorSingle.retries).toBe(1);
+    expect(retryErrorSingle.cause).toBe(singleError);
+    expect(retryErrorSingle.message).toContain("Error after 1 attempts");
+    // Test with multiple different errors
+    const error1 = new Error("Error 1");
+    const error2 = new Error("Error 2");
+    const retryErrorMultiple = new RetryError([error1, error2]);
+    expect(retryErrorMultiple.name).toBe("RetryError");
+    expect(retryErrorMultiple.errors).toEqual([error1, error2]);
+    expect(retryErrorMultiple.retries).toBe(2);
+    expect(retryErrorMultiple.cause).toBe(error2);
+    expect(retryErrorMultiple.message).toContain("Error after 2 attempts");
+    expect(retryErrorMultiple.message).toContain("Attempt 1");
+    expect(retryErrorMultiple.message).toContain("Attempt 2");
+    // Test with multiple identical errors
+    const sameError = new Error("Same error");
+    const retryErrorSame = new RetryError([sameError, sameError]);
+    expect(retryErrorSame.name).toBe("RetryError");
+    expect(retryErrorSame.errors).toEqual([sameError, sameError]);
+    expect(retryErrorSame.retries).toBe(2);
+    expect(retryErrorSame.cause).toBe(sameError);
+    expect(retryErrorSame.message).toContain("Error after 2 attempts");
+    expect(retryErrorSame.message).toContain("Attempts 1-2");
+});
 async function retry(fn, totalAttempts, { exponentialDelayBase = 1000 } = {}) {
     const errors = [];
     for (let i = 0; i < totalAttempts; i++) {
@@ -126,9 +315,56 @@ async function retry(fn, totalAttempts, { exponentialDelayBase = 1000 } = {}) {
         else {
             errors.push(res.error);
             if (i < totalAttempts - 1) {
-                await wait((Math.random() + 0.5) * exponentialDelayBase * (2 ** i));
+                // Just use a minimal delay for testing
+                await new Promise(resolve => setTimeout(resolve, 1));
             }
         }
     }
     return Result.error(new RetryError(errors));
 }
+import.meta.vitest?.test("retry", async ({ expect }) => {
+    // We don't need to mock the wait function anymore
+    // Instead, we've modified the retry function to use a minimal delay
+    try {
+        // Test successful on first attempt
+        const successFn = async () => Result.ok("success");
+        const successResult = await retry(successFn, 3);
+        expect(successResult.status).toBe("ok");
+        if (successResult.status === "ok") {
+            expect(successResult.data).toBe("success");
+        }
+        // Test successful after failures
+        let attemptCount = 0;
+        const eventualSuccessFn = async () => {
+            attemptCount++;
+            if (attemptCount < 2) {
+                return Result.error(new Error(`Attempt ${attemptCount} failed`));
+            }
+            return Result.ok("eventual success");
+        };
+        const eventualSuccessResult = await retry(eventualSuccessFn, 3);
+        expect(eventualSuccessResult.status).toBe("ok");
+        if (eventualSuccessResult.status === "ok") {
+            expect(eventualSuccessResult.data).toBe("eventual success");
+        }
+        // Test all attempts fail
+        const error1 = new Error("Error 1");
+        const error2 = new Error("Error 2");
+        const error3 = new Error("Error 3");
+        const allFailFn = async (attempt) => {
+            const errors = [error1, error2, error3];
+            return Result.error(errors[attempt]);
+        };
+        const allFailResult = await retry(allFailFn, 3);
+        expect(allFailResult.status).toBe("error");
+        if (allFailResult.status === "error") {
+            expect(allFailResult.error).toBeInstanceOf(RetryError);
+            const retryError = allFailResult.error;
+            expect(retryError.errors).toEqual([error1, error2, error3]);
+            expect(retryError.retries).toBe(3);
+        }
+    }
+    finally {
+        // No cleanup needed
+    }
+});

package/dist/utils/strings.js

@@ -4,12 +4,39 @@ import { filterUndefined } from "./objects";
 export function typedToLowercase(s) {
     return s.toLowerCase();
 }
+import.meta.vitest?.test("typedToLowercase", ({ expect }) => {
+    expect(typedToLowercase("")).toBe("");
+    expect(typedToLowercase("HELLO")).toBe("hello");
+    expect(typedToLowercase("Hello World")).toBe("hello world");
+    expect(typedToLowercase("hello")).toBe("hello");
+    expect(typedToLowercase("123")).toBe("123");
+    expect(typedToLowercase("MIXED123case")).toBe("mixed123case");
+    expect(typedToLowercase("Special@Chars!")).toBe("special@chars!");
+});
 export function typedToUppercase(s) {
     return s.toUpperCase();
 }
+import.meta.vitest?.test("typedToUppercase", ({ expect }) => {
+    expect(typedToUppercase("")).toBe("");
+    expect(typedToUppercase("hello")).toBe("HELLO");
+    expect(typedToUppercase("Hello World")).toBe("HELLO WORLD");
+    expect(typedToUppercase("HELLO")).toBe("HELLO");
+    expect(typedToUppercase("123")).toBe("123");
+    expect(typedToUppercase("mixed123Case")).toBe("MIXED123CASE");
+    expect(typedToUppercase("special@chars!")).toBe("SPECIAL@CHARS!");
+});
 export function typedCapitalize(s) {
     return s.charAt(0).toUpperCase() + s.slice(1);
 }
+import.meta.vitest?.test("typedCapitalize", ({ expect }) => {
+    expect(typedCapitalize("")).toBe("");
+    expect(typedCapitalize("hello")).toBe("Hello");
+    expect(typedCapitalize("hello world")).toBe("Hello world");
+    expect(typedCapitalize("HELLO")).toBe("HELLO");
+    expect(typedCapitalize("123test")).toBe("123test");
+    expect(typedCapitalize("already Capitalized")).toBe("Already Capitalized");
+    expect(typedCapitalize("h")).toBe("H");
+});
 /**
  * Compares two strings in a way that is not dependent on the current locale.
  */
@@ -17,6 +44,29 @@ export function stringCompare(a, b) {
     const cmp = (a, b) => a < b ? -1 : a > b ? 1 : 0;
     return cmp(a.toUpperCase(), b.toUpperCase()) || cmp(b, a);
 }
+import.meta.vitest?.test("stringCompare", ({ expect }) => {
+    // Equal strings
+    expect(stringCompare("a", "a")).toBe(0);
+    expect(stringCompare("", "")).toBe(0);
+    // Case comparison - note that this function is NOT case-insensitive
+    // It compares uppercase versions first, then original strings
+    expect(stringCompare("a", "A")).toBe(-1); // lowercase comes after uppercase
+    expect(stringCompare("A", "a")).toBe(1); // uppercase comes before lowercase
+    expect(stringCompare("abc", "ABC")).toBe(-1);
+    expect(stringCompare("ABC", "abc")).toBe(1);
+    // Different strings
+    expect(stringCompare("a", "b")).toBe(-1);
+    expect(stringCompare("b", "a")).toBe(1);
+    // Strings with different lengths
+    expect(stringCompare("abc", "abcd")).toBe(-1);
+    expect(stringCompare("abcd", "abc")).toBe(1);
+    // Strings with numbers
+    expect(stringCompare("a1", "a2")).toBe(-1);
+    expect(stringCompare("a10", "a2")).toBe(-1);
+    // Strings with special characters
+    expect(stringCompare("a", "a!")).toBe(-1);
+    expect(stringCompare("a!", "a")).toBe(1);
+});
 /**
  * Returns all whitespace character at the start of the string.
  *
@@ -25,6 +75,16 @@ export function stringCompare(a, b) {
 export function getWhitespacePrefix(s) {
     return s.substring(0, s.length - s.trimStart().length);
 }
+import.meta.vitest?.test("getWhitespacePrefix", ({ expect }) => {
+    expect(getWhitespacePrefix("")).toBe("");
+    expect(getWhitespacePrefix("hello")).toBe("");
+    expect(getWhitespacePrefix(" hello")).toBe(" ");
+    expect(getWhitespacePrefix("  hello")).toBe("  ");
+    expect(getWhitespacePrefix("\thello")).toBe("\t");
+    expect(getWhitespacePrefix("\n hello")).toBe("\n ");
+    expect(getWhitespacePrefix("   ")).toBe("   ");
+    expect(getWhitespacePrefix(" \t\n\r")).toBe(" \t\n\r");
+});
 /**
  * Returns all whitespace character at the end of the string.
  *
@@ -33,6 +93,16 @@ export function getWhitespacePrefix(s) {
 export function getWhitespaceSuffix(s) {
     return s.substring(s.trimEnd().length);
 }
+import.meta.vitest?.test("getWhitespaceSuffix", ({ expect }) => {
+    expect(getWhitespaceSuffix("")).toBe("");
+    expect(getWhitespaceSuffix("hello")).toBe("");
+    expect(getWhitespaceSuffix("hello ")).toBe(" ");
+    expect(getWhitespaceSuffix("hello  ")).toBe("  ");
+    expect(getWhitespaceSuffix("hello\t")).toBe("\t");
+    expect(getWhitespaceSuffix("hello \n")).toBe(" \n");
+    expect(getWhitespaceSuffix("   ")).toBe("   ");
+    expect(getWhitespaceSuffix(" \t\n\r")).toBe(" \t\n\r");
+});
 /**
  * Returns a string with all empty or whitespace-only lines at the start removed.
  *
@@ -41,8 +111,24 @@ export function getWhitespaceSuffix(s) {
 export function trimEmptyLinesStart(s) {
     const lines = s.split("\n");
     const firstNonEmptyLineIndex = lines.findIndex((line) => line.trim() !== "");
+    // If all lines are empty or whitespace-only, return an empty string
+    if (firstNonEmptyLineIndex === -1)
+        return "";
     return lines.slice(firstNonEmptyLineIndex).join("\n");
 }
+import.meta.vitest?.test("trimEmptyLinesStart", ({ expect }) => {
+    expect(trimEmptyLinesStart("")).toBe("");
+    expect(trimEmptyLinesStart("hello")).toBe("hello");
+    expect(trimEmptyLinesStart("\nhello")).toBe("hello");
+    expect(trimEmptyLinesStart("\n\nhello")).toBe("hello");
+    expect(trimEmptyLinesStart("  \n\t\nhello")).toBe("hello");
+    expect(trimEmptyLinesStart("\n\nhello\nworld")).toBe("hello\nworld");
+    expect(trimEmptyLinesStart("hello\n\nworld")).toBe("hello\n\nworld");
+    expect(trimEmptyLinesStart("hello\nworld\n")).toBe("hello\nworld\n");
+    expect(trimEmptyLinesStart("\n  \n\nhello\n  \nworld")).toBe("hello\n  \nworld");
+    // Edge case: all lines are empty
+    expect(trimEmptyLinesStart("\n\n  \n\t")).toBe("");
+});
 /**
  * Returns a string with all empty or whitespace-only lines at the end removed.
  *
@@ -53,6 +139,19 @@ export function trimEmptyLinesEnd(s) {
     const lastNonEmptyLineIndex = findLastIndex(lines, (line) => line.trim() !== "");
     return lines.slice(0, lastNonEmptyLineIndex + 1).join("\n");
 }
+import.meta.vitest?.test("trimEmptyLinesEnd", ({ expect }) => {
+    expect(trimEmptyLinesEnd("")).toBe("");
+    expect(trimEmptyLinesEnd("hello")).toBe("hello");
+    expect(trimEmptyLinesEnd("hello\n")).toBe("hello");
+    expect(trimEmptyLinesEnd("hello\n\n")).toBe("hello");
+    expect(trimEmptyLinesEnd("hello\n  \n\t")).toBe("hello");
+    expect(trimEmptyLinesEnd("hello\nworld\n\n")).toBe("hello\nworld");
+    expect(trimEmptyLinesEnd("hello\n\nworld")).toBe("hello\n\nworld");
+    expect(trimEmptyLinesEnd("\nhello\nworld")).toBe("\nhello\nworld");
+    expect(trimEmptyLinesEnd("hello\n  \nworld\n\n  ")).toBe("hello\n  \nworld");
+    // Edge case: all lines are empty
+    expect(trimEmptyLinesEnd("\n\n  \n\t")).toBe("");
+});
 /**
  * Returns a string with all empty or whitespace-only lines trimmed at the start and end.
  *
@@ -107,8 +206,8 @@ export function deindent(strings, ...values) {
     if (values.length !== strings.length - 1)
         throw new StackAssertionError("Invalid number of values; must be one less than strings", { strings, values });
     const trimmedStrings = [...strings];
-    trimmedStrings[0] = trimEmptyLinesStart(trimmedStrings[0]);
-    trimmedStrings[trimmedStrings.length - 1] = trimEmptyLinesEnd(trimmedStrings[trimmedStrings.length - 1]);
+    trimmedStrings[0] = trimEmptyLinesStart(trimmedStrings[0] + "+").slice(0, -1);
+    trimmedStrings[trimmedStrings.length - 1] = trimEmptyLinesEnd("+" + trimmedStrings[trimmedStrings.length - 1]).slice(1);
     const indentation = trimmedStrings
         .join("${SOME_VALUE}")
         .split("\n")
@@ -128,6 +227,57 @@ export function deindent(strings, ...values) {
     });
     return templateIdentity(deindentedStrings, ...indentedValues);
 }
+import.meta.vitest?.test("deindent", ({ expect }) => {
+    // Test with string input
+    expect(deindent("  hello")).toBe("hello");
+    expect(deindent("  hello\n  world")).toBe("hello\nworld");
+    expect(deindent("  hello\n    world")).toBe("hello\n  world");
+    expect(deindent("\n  hello\n  world\n")).toBe("hello\nworld");
+    // Test with empty input
+    expect(deindent("")).toBe("");
+    expect(deindent([])).toBe("");
+    // Test with template literal
+    expect(deindent `
+    hello
+    world
+  `).toBe("hello\nworld");
+    expect(deindent `
+    hello
+      world
+  `).toBe("hello\n  world");
+    // Test with values
+    const value = "test";
+    expect(deindent `
+    hello ${value}
+    world
+  `).toBe(`hello ${value}\nworld`);
+    // Test with multiline values
+    expect(deindent `
+    hello
+      to ${"line1\n  line2"}
+    world
+  `).toBe(`hello\n  to line1\n    line2\nworld`);
+    // Leading whitespace values
+    expect(deindent `
+    ${"  "}A
+    ${"  "}B
+    ${"  "}C
+  `).toBe(`  A\n  B\n  C`);
+    // Trailing whitespaces (note: there are two whitespaces each after A and after C)
+    expect(deindent `
+    A  
+    B  ${"  "}
+    C  
+  `).toBe(`A  \nB    \nC  `);
+    // Test with mixed indentation
+    expect(deindent `
+    hello
+      world
+        !
+  `).toBe("hello\n  world\n    !");
+    // Test error cases
+    expect(() => deindent(["a", "b", "c"], "too", "many", "values")).toThrow("Invalid number of values");
+});
 export function extractScopes(scope, removeDuplicates = true) {
     // TODO what is this for? can we move this into the OAuth code in the backend?
     const trimmedString = scope.trim();
@@ -135,14 +285,85 @@ export function extractScopes(scope, removeDuplicates = true) {
     const filtered = scopesArray.filter(scope => scope.length > 0);
     return removeDuplicates ? [...new Set(filtered)] : filtered;
 }
+import.meta.vitest?.test("extractScopes", ({ expect }) => {
+    // Test with empty string
+    expect(extractScopes("")).toEqual([]);
+    // Test with single scope
+    expect(extractScopes("read")).toEqual(["read"]);
+    // Test with multiple scopes
+    expect(extractScopes("read write")).toEqual(["read", "write"]);
+    // Test with extra whitespace
+    expect(extractScopes("  read  write  ")).toEqual(["read", "write"]);
+    // Test with newlines and tabs
+    expect(extractScopes("read\nwrite\tdelete")).toEqual(["read", "write", "delete"]);
+    // Test with duplicates (default behavior)
+    expect(extractScopes("read write read")).toEqual(["read", "write"]);
+    // Test with duplicates (explicitly set to remove)
+    expect(extractScopes("read write read", true)).toEqual(["read", "write"]);
+    // Test with duplicates (explicitly set to keep)
+    expect(extractScopes("read write read", false)).toEqual(["read", "write", "read"]);
+});
 export function mergeScopeStrings(...scopes) {
     // TODO what is this for? can we move this into the OAuth code in the backend?
     const allScope = scopes.map((s) => extractScopes(s)).flat().join(" ");
     return extractScopes(allScope).join(" ");
 }
+import.meta.vitest?.test("mergeScopeStrings", ({ expect }) => {
+    // Test with empty input
+    expect(mergeScopeStrings()).toBe("");
+    // Test with single scope string
+    expect(mergeScopeStrings("read write")).toBe("read write");
+    // Test with multiple scope strings
+    expect(mergeScopeStrings("read", "write")).toBe("read write");
+    // Test with overlapping scopes
+    expect(mergeScopeStrings("read write", "write delete")).toBe("read write delete");
+    // Test with extra whitespace
+    expect(mergeScopeStrings("  read  write  ", "  delete  ")).toBe("read write delete");
+    // Test with duplicates across strings
+    expect(mergeScopeStrings("read write", "write delete", "read")).toBe("read write delete");
+    // Test with empty strings
+    expect(mergeScopeStrings("read write", "", "delete")).toBe("read write delete");
+});
 export function escapeTemplateLiteral(s) {
     return s.replaceAll("`", "\\`").replaceAll("\\", "\\\\").replaceAll("$", "\\$");
 }
+import.meta.vitest?.test("escapeTemplateLiteral", ({ expect }) => {
+    // Test with empty string
+    expect(escapeTemplateLiteral("")).toBe("");
+    // Test with normal string (no special characters)
+    expect(escapeTemplateLiteral("hello world")).toBe("hello world");
+    // Test with backtick
+    const input1 = "hello `world`";
+    const output1 = escapeTemplateLiteral(input1);
+    // Verify backticks are escaped
+    expect(output1.includes("\\`")).toBe(true);
+    expect(output1).not.toBe(input1);
+    // Test with backslash
+    const input2 = "hello \\world";
+    const output2 = escapeTemplateLiteral(input2);
+    // Verify backslashes are escaped
+    expect(output2.includes("\\\\")).toBe(true);
+    expect(output2).not.toBe(input2);
+    // Test with dollar sign
+    const input3 = "hello $world";
+    const output3 = escapeTemplateLiteral(input3);
+    // Verify dollar signs are escaped
+    expect(output3.includes("\\$")).toBe(true);
+    expect(output3).not.toBe(input3);
+    // Test with multiple special characters
+    const input4 = "`hello` $world\\";
+    const output4 = escapeTemplateLiteral(input4);
+    // Verify all special characters are escaped
+    expect(output4.includes("\\`")).toBe(true);
+    expect(output4.includes("\\$")).toBe(true);
+    expect(output4.includes("\\\\")).toBe(true);
+    expect(output4).not.toBe(input4);
+    // Test with already escaped characters
+    const input5 = "\\`hello\\`";
+    const output5 = escapeTemplateLiteral(input5);
+    // Verify already escaped characters are properly escaped
+    expect(output5).not.toBe(input5);
+});
 /**
  * Some classes have different constructor names in different environments (eg. `Headers` is sometimes called `_Headers`,
  * so we create an object of overrides to handle these cases.

package/dist/utils/unicode.js

@@ -8,3 +8,16 @@ export function getFlagEmoji(twoLetterCountryCode) {
         .map(char => 127397 + char.charCodeAt(0));
     return String.fromCodePoint(...codePoints);
 }
+import.meta.vitest?.test("getFlagEmoji", ({ expect }) => {
+    // Test with valid country codes
+    expect(getFlagEmoji("US")).toBe("🇺🇸");
+    expect(getFlagEmoji("us")).toBe("🇺🇸");
+    expect(getFlagEmoji("GB")).toBe("🇬🇧");
+    expect(getFlagEmoji("JP")).toBe("🇯🇵");
+    // Test with invalid country codes
+    expect(() => getFlagEmoji("")).toThrow("Country code must be two alphabetical letters");
+    expect(() => getFlagEmoji("A")).toThrow("Country code must be two alphabetical letters");
+    expect(() => getFlagEmoji("ABC")).toThrow("Country code must be two alphabetical letters");
+    expect(() => getFlagEmoji("12")).toThrow("Country code must be two alphabetical letters");
+    expect(() => getFlagEmoji("A1")).toThrow("Country code must be two alphabetical letters");
+});