@stackframe/stack-shared 2.7.20 → 2.7.21

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");
+});

package/dist/utils/urls.js

@@ -8,15 +8,47 @@ export function createUrlIfValid(...args) {
         return null;
     }
 }
+import.meta.vitest?.test("createUrlIfValid", ({ expect }) => {
+    // Test with valid URLs
+    expect(createUrlIfValid("https://example.com")).toBeInstanceOf(URL);
+    expect(createUrlIfValid("https://example.com/path?query=value#hash")).toBeInstanceOf(URL);
+    expect(createUrlIfValid("/path", "https://example.com")).toBeInstanceOf(URL);
+    // Test with invalid URLs
+    expect(createUrlIfValid("")).toBeNull();
+    expect(createUrlIfValid("not a url")).toBeNull();
+    expect(createUrlIfValid("http://")).toBeNull();
+});
 export function isValidUrl(url) {
     return !!createUrlIfValid(url);
 }
+import.meta.vitest?.test("isValidUrl", ({ expect }) => {
+    // Test with valid URLs
+    expect(isValidUrl("https://example.com")).toBe(true);
+    expect(isValidUrl("http://localhost:3000")).toBe(true);
+    expect(isValidUrl("ftp://example.com")).toBe(true);
+    // Test with invalid URLs
+    expect(isValidUrl("")).toBe(false);
+    expect(isValidUrl("not a url")).toBe(false);
+    expect(isValidUrl("http://")).toBe(false);
+});
 export function isValidHostname(hostname) {
     const url = createUrlIfValid(`https://${hostname}`);
     if (!url)
         return false;
     return url.hostname === hostname;
 }
+import.meta.vitest?.test("isValidHostname", ({ expect }) => {
+    // Test with valid hostnames
+    expect(isValidHostname("example.com")).toBe(true);
+    expect(isValidHostname("localhost")).toBe(true);
+    expect(isValidHostname("sub.domain.example.com")).toBe(true);
+    expect(isValidHostname("127.0.0.1")).toBe(true);
+    // Test with invalid hostnames
+    expect(isValidHostname("")).toBe(false);
+    expect(isValidHostname("example.com/path")).toBe(false);
+    expect(isValidHostname("https://example.com")).toBe(false);
+    expect(isValidHostname("example com")).toBe(false);
+});
 export function isLocalhost(urlOrString) {
     const url = createUrlIfValid(urlOrString);
     if (!url)
@@ -27,6 +59,24 @@ export function isLocalhost(urlOrString) {
         return true;
     return false;
 }
+import.meta.vitest?.test("isLocalhost", ({ expect }) => {
+    // Test with localhost URLs
+    expect(isLocalhost("http://localhost")).toBe(true);
+    expect(isLocalhost("https://localhost:8080")).toBe(true);
+    expect(isLocalhost("http://sub.localhost")).toBe(true);
+    expect(isLocalhost("http://127.0.0.1")).toBe(true);
+    expect(isLocalhost("http://127.1.2.3")).toBe(true);
+    // Test with non-localhost URLs
+    expect(isLocalhost("https://example.com")).toBe(false);
+    expect(isLocalhost("http://192.168.1.1")).toBe(false);
+    expect(isLocalhost("http://10.0.0.1")).toBe(false);
+    // Test with URL objects
+    expect(isLocalhost(new URL("http://localhost"))).toBe(true);
+    expect(isLocalhost(new URL("https://example.com"))).toBe(false);
+    // Test with invalid URLs
+    expect(isLocalhost("not a url")).toBe(false);
+    expect(isLocalhost("")).toBe(false);
+});
 export function isRelative(url) {
     const randomDomain = `${generateSecureRandomString()}.stack-auth.example.com`;
     const u = createUrlIfValid(url, `https://${randomDomain}`);
@@ -38,9 +88,37 @@ export function isRelative(url) {
         return false;
     return true;
 }
+import.meta.vitest?.test("isRelative", ({ expect }) => {
+    // We can't easily mock generateSecureRandomString in this context
+    // but we can still test the function's behavior
+    // Test with relative URLs
+    expect(isRelative("/")).toBe(true);
+    expect(isRelative("/path")).toBe(true);
+    expect(isRelative("/path?query=value#hash")).toBe(true);
+    // Test with absolute URLs
+    expect(isRelative("https://example.com")).toBe(false);
+    expect(isRelative("http://example.com")).toBe(false);
+    expect(isRelative("//example.com")).toBe(false);
+    // Note: The implementation treats empty strings and invalid URLs as relative
+    // This is because they can be resolved against a base URL
+    expect(isRelative("")).toBe(true);
+    expect(isRelative("not a url")).toBe(true);
+});
 export function getRelativePart(url) {
     return url.pathname + url.search + url.hash;
 }
+import.meta.vitest?.test("getRelativePart", ({ expect }) => {
+    // Test with various URLs
+    expect(getRelativePart(new URL("https://example.com"))).toBe("/");
+    expect(getRelativePart(new URL("https://example.com/path"))).toBe("/path");
+    expect(getRelativePart(new URL("https://example.com/path?query=value"))).toBe("/path?query=value");
+    expect(getRelativePart(new URL("https://example.com/path#hash"))).toBe("/path#hash");
+    expect(getRelativePart(new URL("https://example.com/path?query=value#hash"))).toBe("/path?query=value#hash");
+    // Test with different domains but same paths
+    const url1 = new URL("https://example.com/path?query=value#hash");
+    const url2 = new URL("https://different.com/path?query=value#hash");
+    expect(getRelativePart(url1)).toBe(getRelativePart(url2));
+});
 /**
  * A template literal tag that returns a URL.
  *
@@ -49,6 +127,27 @@ export function getRelativePart(url) {
 export function url(strings, ...values) {
     return new URL(urlString(strings, ...values));
 }
+import.meta.vitest?.test("url", ({ expect }) => {
+    // Test with no interpolation
+    expect(url `https://example.com`).toBeInstanceOf(URL);
+    expect(url `https://example.com`.href).toBe("https://example.com/");
+    // Test with string interpolation
+    expect(url `https://example.com/${"path"}`).toBeInstanceOf(URL);
+    expect(url `https://example.com/${"path"}`.pathname).toBe("/path");
+    // Test with number interpolation
+    expect(url `https://example.com/${42}`).toBeInstanceOf(URL);
+    expect(url `https://example.com/${42}`.pathname).toBe("/42");
+    // Test with boolean interpolation
+    expect(url `https://example.com/${true}`).toBeInstanceOf(URL);
+    expect(url `https://example.com/${true}`.pathname).toBe("/true");
+    // Test with special characters in interpolation
+    expect(url `https://example.com/${"path with spaces"}`).toBeInstanceOf(URL);
+    expect(url `https://example.com/${"path with spaces"}`.pathname).toBe("/path%20with%20spaces");
+    // Test with multiple interpolations
+    expect(url `https://example.com/${"path"}?query=${"value"}`).toBeInstanceOf(URL);
+    expect(url `https://example.com/${"path"}?query=${"value"}`.pathname).toBe("/path");
+    expect(url `https://example.com/${"path"}?query=${"value"}`.search).toBe("?query=value");
+});
 /**
  * A template literal tag that returns a URL string.
  *
@@ -57,3 +156,19 @@ export function url(strings, ...values) {
 export function urlString(strings, ...values) {
     return templateIdentity(strings, ...values.map(encodeURIComponent));
 }
+import.meta.vitest?.test("urlString", ({ expect }) => {
+    // Test with no interpolation
+    expect(urlString `https://example.com`).toBe("https://example.com");
+    // Test with string interpolation
+    expect(urlString `https://example.com/${"path"}`).toBe("https://example.com/path");
+    // Test with number interpolation
+    expect(urlString `https://example.com/${42}`).toBe("https://example.com/42");
+    // Test with boolean interpolation
+    expect(urlString `https://example.com/${true}`).toBe("https://example.com/true");
+    // Test with special characters in interpolation
+    expect(urlString `https://example.com/${"path with spaces"}`).toBe("https://example.com/path%20with%20spaces");
+    expect(urlString `https://example.com/${"?&="}`).toBe("https://example.com/%3F%26%3D");
+    // Test with multiple interpolations
+    expect(urlString `https://example.com/${"path"}?query=${"value"}`).toBe("https://example.com/path?query=value");
+    expect(urlString `https://example.com/${"path"}?query=${"value with spaces"}`).toBe("https://example.com/path?query=value%20with%20spaces");
+});

package/dist/utils/uuids.js

@@ -3,6 +3,36 @@ export function generateUuid() {
     // crypto.randomUuid is not supported in all browsers, so this is a polyfill
     return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, c => (+c ^ generateRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16));
 }
+import.meta.vitest?.test("generateUuid", ({ expect }) => {
+    // Test that the function returns a valid UUID
+    const uuid = generateUuid();
+    expect(uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+    // Test that multiple calls generate different UUIDs
+    const uuid2 = generateUuid();
+    expect(uuid).not.toBe(uuid2);
+    // Test that the UUID is version 4 (random)
+    expect(uuid.charAt(14)).toBe('4');
+    // Test that the UUID has the correct variant (8, 9, a, or b in position 19)
+    expect('89ab').toContain(uuid.charAt(19));
+});
 export function isUuid(str) {
     return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(str);
 }
+import.meta.vitest?.test("isUuid", ({ expect }) => {
+    // Test with valid UUIDs
+    expect(isUuid("123e4567-e89b-42d3-a456-426614174000")).toBe(true);
+    expect(isUuid("123e4567-e89b-42d3-8456-426614174000")).toBe(true);
+    expect(isUuid("123e4567-e89b-42d3-9456-426614174000")).toBe(true);
+    expect(isUuid("123e4567-e89b-42d3-a456-426614174000")).toBe(true);
+    expect(isUuid("123e4567-e89b-42d3-b456-426614174000")).toBe(true);
+    // Test with invalid UUIDs
+    expect(isUuid("")).toBe(false);
+    expect(isUuid("not-a-uuid")).toBe(false);
+    expect(isUuid("123e4567-e89b-12d3-a456-426614174000")).toBe(false); // Wrong version (not 4)
+    expect(isUuid("123e4567-e89b-42d3-c456-426614174000")).toBe(false); // Wrong variant (not 8, 9, a, or b)
+    expect(isUuid("123e4567-e89b-42d3-a456-42661417400")).toBe(false); // Too short
+    expect(isUuid("123e4567-e89b-42d3-a456-4266141740000")).toBe(false); // Too long
+    expect(isUuid("123e4567-e89b-42d3-a456_426614174000")).toBe(false); // Wrong format (underscore instead of dash)
+    // Test with uppercase letters (should fail as UUID should be lowercase)
+    expect(isUuid("123E4567-E89B-42D3-A456-426614174000")).toBe(false);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.7.20",
+  "version": "2.7.21",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",