@stackframe/stack-shared 2.7.19 → 2.7.21

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.19",
+  "version": "2.7.21",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
@@ -23,7 +23,6 @@
   "peerDependencies": {
     "@types/react": ">=18.2 || >=19.0.0-rc.0",
     "@types/react-dom": ">=18.2 || >=19.0.0-rc.0",
-    "next": ">=14.1.0 || >=15.0.0-rc.0",
     "react": ">=18.2 || >=19.0.0-rc.0",
     "react-dom": ">=18.2 || >=19.0.0-rc.0",
     "yup": "^1.4.0"
@@ -51,8 +50,7 @@
     "jose": "^5.2.2",
     "oauth4webapi": "^2.10.3",
     "semver": "^7.6.3",
-    "uuid": "^9.0.1",
-    "@stackframe/stack-sc": "2.7.19"
+    "uuid": "^9.0.1"
   },
   "devDependencies": {
     "@sentry/nextjs": "^8.40.0",
@@ -61,7 +59,6 @@
     "@types/elliptic": "^6.4.18",
     "@types/semver": "^7.5.8",
     "@types/uuid": "^9.0.8",
-    "next": "^14.1.0",
     "react": "^18.2",
     "react-dom": "^18.2",
     "rimraf": "^5.0.5"