@stackframe/stack-shared 2.7.20 → 2.7.22

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @stackframe/stack-shared
 
+## 2.7.22
+
+### Patch Changes
+
+- Various changes
+
+## 2.7.21
+
+### Patch Changes
+
+- Various changes
+
 ## 2.7.20
 
 ### Patch Changes

package/dist/crud.js

@@ -52,3 +52,79 @@ export function createCrud(options) {
         hasDelete: !!admin.deleteSchema,
     };
 }
+import { yupObject, yupString } from './schema-fields';
+import.meta.vitest?.test("createCrud", ({ expect }) => {
+    // Test with empty options
+    const emptyCrud = createCrud({});
+    expect(emptyCrud.hasCreate).toBe(false);
+    expect(emptyCrud.hasRead).toBe(false);
+    expect(emptyCrud.hasUpdate).toBe(false);
+    expect(emptyCrud.hasDelete).toBe(false);
+    expect(emptyCrud.client.createSchema).toBeUndefined();
+    expect(emptyCrud.server.createSchema).toBeUndefined();
+    expect(emptyCrud.admin.createSchema).toBeUndefined();
+    // Test with client schemas only
+    const mockSchema = yupObject().shape({
+        name: yupString().defined(),
+    });
+    const clientOnlyCrud = createCrud({
+        clientCreateSchema: mockSchema,
+        clientReadSchema: mockSchema,
+    });
+    expect(clientOnlyCrud.hasCreate).toBe(true);
+    expect(clientOnlyCrud.hasRead).toBe(true);
+    expect(clientOnlyCrud.hasUpdate).toBe(false);
+    expect(clientOnlyCrud.hasDelete).toBe(false);
+    expect(clientOnlyCrud.client.createSchema).toBe(mockSchema);
+    expect(clientOnlyCrud.server.createSchema).toBe(mockSchema);
+    expect(clientOnlyCrud.admin.createSchema).toBe(mockSchema);
+    // Test with server overrides
+    const serverSchema = yupObject().shape({
+        name: yupString().defined(),
+        internalField: yupString().defined(),
+    });
+    const serverOverrideCrud = createCrud({
+        clientCreateSchema: mockSchema,
+        serverCreateSchema: serverSchema,
+    });
+    expect(serverOverrideCrud.hasCreate).toBe(true);
+    expect(serverOverrideCrud.client.createSchema).toBe(mockSchema);
+    expect(serverOverrideCrud.server.createSchema).toBe(serverSchema);
+    expect(serverOverrideCrud.admin.createSchema).toBe(serverSchema);
+    // Test with admin overrides
+    const adminSchema = yupObject().shape({
+        name: yupString().defined(),
+        internalField: yupString().defined(),
+        adminField: yupString().defined(),
+    });
+    const fullOverrideCrud = createCrud({
+        clientCreateSchema: mockSchema,
+        serverCreateSchema: serverSchema,
+        adminCreateSchema: adminSchema,
+    });
+    expect(fullOverrideCrud.hasCreate).toBe(true);
+    expect(fullOverrideCrud.client.createSchema).toBe(mockSchema);
+    expect(fullOverrideCrud.server.createSchema).toBe(serverSchema);
+    expect(fullOverrideCrud.admin.createSchema).toBe(adminSchema);
+    // Test with documentation
+    const crudWithDocs = createCrud({
+        clientCreateSchema: mockSchema,
+        docs: {
+            clientCreate: {
+                summary: "Create a resource",
+                description: "Creates a new resource",
+                tags: ["resources"],
+            },
+        },
+    });
+    expect(crudWithDocs.client.createDocs).toEqual({
+        summary: "Create a resource",
+        description: "Creates a new resource",
+        tags: ["resources"],
+    });
+    expect(crudWithDocs.server.createDocs).toEqual({
+        summary: "Create a resource",
+        description: "Creates a new resource",
+        tags: ["resources"],
+    });
+});

package/dist/hooks/use-strict-memo.js

@@ -27,6 +27,41 @@ function unwrapFromInner(dependencies, inner) {
         }
     }
 }
+import.meta.vitest?.test("unwrapFromInner", ({ expect }) => {
+    // Test with empty dependencies and non-nested map
+    const nonNestedMap = { isNotNestedMap: true, value: "test" };
+    const result1 = unwrapFromInner([], nonNestedMap);
+    expect(result1.status).toBe("ok");
+    if (result1.status === "ok") {
+        expect(result1.data).toBe("test");
+    }
+    // Test with non-empty dependencies and non-nested map (should error)
+    expect(unwrapFromInner(["key"], nonNestedMap).status).toBe("error");
+    // Test with empty dependencies and nested map (should error)
+    const nestedMap = new Map([["key", { isNotNestedMap: true, value: "test" }]]);
+    expect(unwrapFromInner([], nestedMap).status).toBe("error");
+    // Test with matching dependencies and nested map
+    const result2 = unwrapFromInner(["key"], nestedMap);
+    expect(result2.status).toBe("ok");
+    if (result2.status === "ok") {
+        expect(result2.data).toBe("test");
+    }
+    // Test with non-matching dependencies and nested map
+    expect(unwrapFromInner(["wrongKey"], nestedMap).status).toBe("error");
+    // Test with deeply nested map
+    const deeplyNestedMap = new Map([
+        ["key1", new Map([
+                ["key2", { isNotNestedMap: true, value: "nested" }]
+            ])]
+    ]);
+    const result3 = unwrapFromInner(["key1", "key2"], deeplyNestedMap);
+    expect(result3.status).toBe("ok");
+    if (result3.status === "ok") {
+        expect(result3.data).toBe("nested");
+    }
+    // Test with partial match in deeply nested map
+    expect(unwrapFromInner(["key1", "wrongKey"], deeplyNestedMap).status).toBe("error");
+});
 function wrapToInner(dependencies, value) {
     if (dependencies.length === 0) {
         return { isNotNestedMap: true, value };
@@ -39,6 +74,46 @@ function wrapToInner(dependencies, value) {
     const mapType = isWeak ? WeakMap : Map;
     return new mapType([[key, inner]]);
 }
+import.meta.vitest?.test("wrapToInner", ({ expect }) => {
+    // Test with empty dependencies
+    const emptyResult = wrapToInner([], "test");
+    expect(emptyResult).toEqual({ isNotNestedMap: true, value: "test" });
+    // Test with single string dependency
+    const singleResult = wrapToInner(["key"], "test");
+    expect(singleResult instanceof Map).toBe(true);
+    // Need to cast to access Map methods
+    const singleMap = singleResult;
+    expect(singleMap.get("key")).toEqual({ isNotNestedMap: true, value: "test" });
+    // Test with multiple string dependencies
+    const multiResult = wrapToInner(["key1", "key2"], "test");
+    expect(multiResult instanceof Map).toBe(true);
+    // Need to cast to access Map methods
+    const multiMap = multiResult;
+    const innerMap = multiMap.get("key1");
+    expect(innerMap instanceof Map).toBe(true);
+    expect(innerMap.get("key2")).toEqual({ isNotNestedMap: true, value: "test" });
+    // Test with object dependency (should use WeakMap)
+    const obj = { test: true };
+    const objResult = wrapToInner([obj], "test");
+    expect(objResult instanceof WeakMap).toBe(true);
+    // Need to cast to access WeakMap methods
+    const objMap = objResult;
+    expect(objMap.get(obj)).toEqual({ isNotNestedMap: true, value: "test" });
+    // Test with unregistered symbol dependency (should use WeakMap)
+    const symbolObj = Symbol("test");
+    const symbolResult = wrapToInner([symbolObj], "test");
+    expect(symbolResult instanceof WeakMap).toBe(true);
+    // Need to cast to access WeakMap methods
+    const symbolMap = symbolResult;
+    expect(symbolMap.get(symbolObj)).toEqual({ isNotNestedMap: true, value: "test" });
+    // Test with registered symbol dependency (should use Map)
+    const registeredSymbol = Symbol.for("test");
+    const registeredSymbolResult = wrapToInner([registeredSymbol], "test");
+    expect(registeredSymbolResult instanceof Map).toBe(true);
+    // Need to cast to access Map methods
+    const registeredSymbolMap = registeredSymbolResult;
+    expect(registeredSymbolMap.get(registeredSymbol)).toEqual({ isNotNestedMap: true, value: "test" });
+});
 /**
  * Like memo, but minimizes recomputation of the value at all costs (instead of useMemo which recomputes whenever the renderer feels like it).
  *

package/dist/interface/serverInterface.d.ts

@@ -89,7 +89,7 @@ export declare class StackServerInterface extends StackClientInterface {
     }): Promise<void>;
     grantServerTeamUserPermission(teamId: string, userId: string, permissionId: string): Promise<void>;
     revokeServerTeamUserPermission(teamId: string, userId: string, permissionId: string): Promise<void>;
-    deleteServerServerUser(userId: string): Promise<void>;
+    deleteServerUser(userId: string): Promise<void>;
     createServerContactChannel(data: ContactChannelsCrud['Server']['Create']): Promise<ContactChannelsCrud['Server']['Read']>;
     updateServerContactChannel(userId: string, contactChannelId: string, data: ContactChannelsCrud['Server']['Update']): Promise<ContactChannelsCrud['Server']['Read']>;
     deleteServerContactChannel(userId: string, contactChannelId: string): Promise<void>;

package/dist/interface/serverInterface.js

@@ -235,7 +235,7 @@ export class StackServerInterface extends StackClientInterface {
             body: JSON.stringify({}),
         }, null);
     }
-    async deleteServerServerUser(userId) {
+    async deleteServerUser(userId) {
         await this.sendServerRequest(urlString `/users/${userId}`, {
             method: "DELETE",
             headers: {

package/dist/known-errors.js

@@ -54,7 +54,7 @@ function createKnownErrorConstructor(SuperClass, errorCode, create, constructorA
     // @ts-expect-error this is not a mixin, but TS detects it as one
     class KnownErrorImpl extends SuperClass {
         constructor(...args) {
-            // @ts-expect-error
+            // @ts-expect-error DEVIN, STOP REMOVING THIS LINE YOU DUMBASS, YES TYPESCRIPT DOES THROW AN ERROR IF YOU DON'T HAVE IT, NO THIS IS NOT "UNUSED", AND YES YOU ARE BREAKING OUR CI PIPELINE EVERY TIME YOU DO IT
             super(...createFn(...args));
             this.name = `KnownError<${errorCode}>`;
             this.constructorArgs = args;

package/dist/utils/arrays.js

@@ -2,9 +2,23 @@ import { remainder } from "./math";
 export function typedIncludes(arr, item) {
     return arr.includes(item);
 }
+import.meta.vitest?.test("typedIncludes", ({ expect }) => {
+    const arr = [1, 2, 3];
+    expect(typedIncludes(arr, 1)).toBe(true);
+    expect(typedIncludes(arr, 4)).toBe(false);
+    expect(typedIncludes(arr, "1")).toBe(false);
+    const strArr = ["a", "b", "c"];
+    expect(typedIncludes(strArr, "a")).toBe(true);
+    expect(typedIncludes(strArr, "d")).toBe(false);
+});
 export function enumerate(arr) {
     return arr.map((item, index) => [index, item]);
 }
+import.meta.vitest?.test("enumerate", ({ expect }) => {
+    expect(enumerate([])).toEqual([]);
+    expect(enumerate([1, 2, 3])).toEqual([[0, 1], [1, 2], [2, 3]]);
+    expect(enumerate(["a", "b", "c"])).toEqual([[0, "a"], [1, "b"], [2, "c"]]);
+});
 export function isShallowEqual(a, b) {
     if (a.length !== b.length)
         return false;
@@ -53,6 +67,22 @@ export function groupBy(arr, key) {
     }
     return result;
 }
+import.meta.vitest?.test("groupBy", ({ expect }) => {
+    expect(groupBy([], (x) => x)).toEqual(new Map());
+    const numbers = [1, 2, 3, 4, 5, 6];
+    const grouped = groupBy(numbers, (n) => n % 2 === 0 ? "even" : "odd");
+    expect(grouped.get("even")).toEqual([2, 4, 6]);
+    expect(grouped.get("odd")).toEqual([1, 3, 5]);
+    // Check the actual lengths of the words to ensure our test is correct
+    const words = ["apple", "banana", "cherry", "date", "elderberry"];
+    console.log("Word lengths:", words.map(w => `${w}: ${w.length}`));
+    const byLength = groupBy(words, (w) => w.length);
+    // Adjust expectations based on actual word lengths
+    expect(byLength.get(5)).toEqual(["apple"]);
+    expect(byLength.get(6)).toEqual(["banana", "cherry"]);
+    expect(byLength.get(4)).toEqual(["date"]);
+    expect(byLength.get(10)).toEqual(["elderberry"]);
+});
 export function range(startInclusive, endExclusive, step) {
     if (endExclusive === undefined) {
         endExclusive = startInclusive;
@@ -75,12 +105,30 @@ import.meta.vitest?.test("range", ({ expect }) => {
     expect(range(0, 10, 3)).toEqual([0, 3, 6, 9]);
 });
 export function rotateLeft(arr, n) {
+    if (arr.length === 0)
+        return [];
     const index = remainder(n, arr.length);
-    return [...arr.slice(n), arr.slice(0, n)];
+    return [...arr.slice(index), ...arr.slice(0, index)];
 }
+import.meta.vitest?.test("rotateLeft", ({ expect }) => {
+    expect(rotateLeft([], 1)).toEqual([]);
+    expect(rotateLeft([1, 2, 3, 4, 5], 0)).toEqual([1, 2, 3, 4, 5]);
+    expect(rotateLeft([1, 2, 3, 4, 5], 1)).toEqual([2, 3, 4, 5, 1]);
+    expect(rotateLeft([1, 2, 3, 4, 5], 3)).toEqual([4, 5, 1, 2, 3]);
+    expect(rotateLeft([1, 2, 3, 4, 5], 5)).toEqual([1, 2, 3, 4, 5]);
+    expect(rotateLeft([1, 2, 3, 4, 5], 6)).toEqual([2, 3, 4, 5, 1]);
+});
 export function rotateRight(arr, n) {
     return rotateLeft(arr, -n);
 }
+import.meta.vitest?.test("rotateRight", ({ expect }) => {
+    expect(rotateRight([], 1)).toEqual([]);
+    expect(rotateRight([1, 2, 3, 4, 5], 0)).toEqual([1, 2, 3, 4, 5]);
+    expect(rotateRight([1, 2, 3, 4, 5], 1)).toEqual([5, 1, 2, 3, 4]);
+    expect(rotateRight([1, 2, 3, 4, 5], 3)).toEqual([3, 4, 5, 1, 2]);
+    expect(rotateRight([1, 2, 3, 4, 5], 5)).toEqual([1, 2, 3, 4, 5]);
+    expect(rotateRight([1, 2, 3, 4, 5], 6)).toEqual([5, 1, 2, 3, 4]);
+});
 export function shuffle(arr) {
     const result = [...arr];
     for (let i = result.length - 1; i > 0; i--) {
@@ -89,9 +137,35 @@ export function shuffle(arr) {
     }
     return result;
 }
+import.meta.vitest?.test("shuffle", ({ expect }) => {
+    // Test empty array
+    expect(shuffle([])).toEqual([]);
+    // Test single element array
+    expect(shuffle([1])).toEqual([1]);
+    // Test that shuffle returns a new array
+    const original = [1, 2, 3, 4, 5];
+    const shuffled = shuffle(original);
+    expect(shuffled).not.toBe(original);
+    // Test that all elements are preserved
+    expect(shuffled.sort((a, b) => a - b)).toEqual(original);
+    // Test with a larger array to ensure randomness
+    // This is a probabilistic test, but it's very unlikely to fail
+    const large = Array.from({ length: 100 }, (_, i) => i);
+    const shuffledLarge = shuffle(large);
+    expect(shuffledLarge).not.toEqual(large);
+    expect(shuffledLarge.sort((a, b) => a - b)).toEqual(large);
+});
 export function outerProduct(arr1, arr2) {
     return arr1.flatMap((item1) => arr2.map((item2) => [item1, item2]));
 }
+import.meta.vitest?.test("outerProduct", ({ expect }) => {
+    expect(outerProduct([], [])).toEqual([]);
+    expect(outerProduct([1], [])).toEqual([]);
+    expect(outerProduct([], [1])).toEqual([]);
+    expect(outerProduct([1], [2])).toEqual([[1, 2]]);
+    expect(outerProduct([1, 2], [3, 4])).toEqual([[1, 3], [1, 4], [2, 3], [2, 4]]);
+    expect(outerProduct(["a", "b"], [1, 2])).toEqual([["a", 1], ["a", 2], ["b", 1], ["b", 2]]);
+});
 export function unique(arr) {
     return [...new Set(arr)];
 }

package/dist/utils/caches.js

@@ -16,6 +16,39 @@ export function cacheFunction(f) {
         return value;
     });
 }
+import.meta.vitest?.test("cacheFunction", ({ expect }) => {
+    // Test with a simple function
+    let callCount = 0;
+    const add = (a, b) => {
+        callCount++;
+        return a + b;
+    };
+    const cachedAdd = cacheFunction(add);
+    // First call should execute the function
+    expect(cachedAdd(1, 2)).toBe(3);
+    expect(callCount).toBe(1);
+    // Second call with same args should use cached result
+    expect(cachedAdd(1, 2)).toBe(3);
+    expect(callCount).toBe(1);
+    // Call with different args should execute the function again
+    expect(cachedAdd(2, 3)).toBe(5);
+    expect(callCount).toBe(2);
+    // Test with a function that returns objects
+    let objectCallCount = 0;
+    const createObject = (id) => {
+        objectCallCount++;
+        return { id };
+    };
+    const cachedCreateObject = cacheFunction(createObject);
+    // First call should execute the function
+    const obj1 = cachedCreateObject(1);
+    expect(obj1).toEqual({ id: 1 });
+    expect(objectCallCount).toBe(1);
+    // Second call with same args should use cached result
+    const obj2 = cachedCreateObject(1);
+    expect(obj2).toBe(obj1); // Same reference
+    expect(objectCallCount).toBe(1);
+});
 export class AsyncCache {
     constructor(_fetcher, _options = {}) {
         this._fetcher = _fetcher;

package/dist/utils/compile-time.js

@@ -4,5 +4,8 @@
  * to exist at runtime).
  */
 export function scrambleDuringCompileTime(t) {
+    if (Math.random() < 0.00001 && Math.random() > 0.99999 && Math.random() < 0.00001 && Math.random() > 0.99999) {
+        return "this will never happen";
+    }
     return t;
 }

package/dist/utils/dates.js

@@ -4,13 +4,13 @@ export function isWeekend(date) {
 }
 import.meta.vitest?.test("isWeekend", ({ expect }) => {
     // Sunday (day 0)
-    expect(isWeekend(new Date("2023-01-01"))).toBe(true);
+    expect(isWeekend(new Date(2023, 0, 1))).toBe(true);
     // Saturday (day 6)
-    expect(isWeekend(new Date("2023-01-07"))).toBe(true);
+    expect(isWeekend(new Date(2023, 0, 7))).toBe(true);
     // Monday (day 1)
-    expect(isWeekend(new Date("2023-01-02"))).toBe(false);
+    expect(isWeekend(new Date(2023, 0, 2))).toBe(false);
     // Friday (day 5)
-    expect(isWeekend(new Date("2023-01-06"))).toBe(false);
+    expect(isWeekend(new Date(2023, 0, 6))).toBe(false);
 });
 const agoUnits = [
     [60, 'second'],

package/dist/utils/functions.js

@@ -1,6 +1,21 @@
 export function identity(t) {
     return t;
 }
+import.meta.vitest?.test("identity", ({ expect }) => {
+    expect(identity(1)).toBe(1);
+    expect(identity("test")).toBe("test");
+    expect(identity(null)).toBe(null);
+    expect(identity(undefined)).toBe(undefined);
+    const obj = { a: 1 };
+    expect(identity(obj)).toBe(obj);
+});
 export function identityArgs(...args) {
     return args;
 }
+import.meta.vitest?.test("identityArgs", ({ expect }) => {
+    expect(identityArgs()).toEqual([]);
+    expect(identityArgs(1)).toEqual([1]);
+    expect(identityArgs(1, 2, 3)).toEqual([1, 2, 3]);
+    expect(identityArgs("a", "b", "c")).toEqual(["a", "b", "c"]);
+    expect(identityArgs(null, undefined)).toEqual([null, undefined]);
+});

package/dist/utils/html.js

@@ -7,6 +7,34 @@ export function escapeHtml(unsafe) {
         .replace(/"/g, """)
         .replace(/'/g, "'");
 }
+import.meta.vitest?.test("escapeHtml", ({ expect }) => {
+    // Test with empty string
+    expect(escapeHtml("")).toBe("");
+    // Test with string without special characters
+    expect(escapeHtml("hello world")).toBe("hello world");
+    // Test with special characters
+    expect(escapeHtml("<div>")).toBe("&lt;div&gt;");
+    expect(escapeHtml("a & b")).toBe("a &amp; b");
+    expect(escapeHtml('a "quoted" string')).toBe("a &quot;quoted&quot; string");
+    expect(escapeHtml("it's a test")).toBe("it&#039;s a test");
+    // Test with multiple special characters
+    expect(escapeHtml("<a href=\"test\">It's a link</a>")).toBe("&lt;a href=&quot;test&quot;&gt;It&#039;s a link&lt;/a&gt;");
+});
 export function html(strings, ...values) {
     return templateIdentity(strings, ...values.map(v => escapeHtml(`${v}`)));
 }
+import.meta.vitest?.test("html", ({ expect }) => {
+    // Test with no interpolation
+    expect(html `simple string`).toBe("simple string");
+    // Test with string interpolation
+    expect(html `Hello, ${"world"}!`).toBe("Hello, world!");
+    // Test with number interpolation
+    expect(html `Count: ${42}`).toBe("Count: 42");
+    // Test with HTML special characters in interpolated values
+    expect(html `<div>${"<script>"}</div>`).toBe("<div>&lt;script&gt;</div>");
+    // Test with multiple interpolations
+    expect(html `${1} + ${2} = ${"<3"}`).toBe("1 + 2 = &lt;3");
+    // Test with object interpolation
+    const obj = { toString: () => "<object>" };
+    expect(html `Object: ${obj}`).toBe("Object: &lt;object&gt;");
+});

package/dist/utils/http.js

@@ -51,8 +51,37 @@ export function decodeBasicAuthorizationHeader(value) {
     const split = decoded.split(':');
     return [split[0], split.slice(1).join(':')];
 }
+import.meta.vitest?.test("decodeBasicAuthorizationHeader", ({ expect }) => {
+    // Test with valid Basic Authorization header
+    const username = "user";
+    const password = "pass";
+    const encoded = encodeBasicAuthorizationHeader(username, password);
+    expect(decodeBasicAuthorizationHeader(encoded)).toEqual([username, password]);
+    // Test with password containing colons
+    const complexPassword = "pass:with:colons";
+    const encodedComplex = encodeBasicAuthorizationHeader(username, complexPassword);
+    expect(decodeBasicAuthorizationHeader(encodedComplex)).toEqual([username, complexPassword]);
+    // Test with invalid headers
+    expect(decodeBasicAuthorizationHeader("NotBasic dXNlcjpwYXNz")).toBe(null); // Wrong type
+    expect(decodeBasicAuthorizationHeader("Basic")).toBe(null); // Missing encoded part
+    expect(decodeBasicAuthorizationHeader("Basic not-base64")).toBe(null); // Not base64
+    expect(decodeBasicAuthorizationHeader("Basic dXNlcjpwYXNz extra")).toBe(null); // Extra parts
+});
 export function encodeBasicAuthorizationHeader(id, password) {
     if (id.includes(':'))
         throw new Error("Basic authorization header id cannot contain ':'");
     return `Basic ${encodeBase64(new TextEncoder().encode(`${id}:${password}`))}`;
 }
+import.meta.vitest?.test("encodeBasicAuthorizationHeader", ({ expect }) => {
+    // Test with simple username and password
+    const encoded = encodeBasicAuthorizationHeader("user", "pass");
+    expect(encoded).toMatch(/^Basic [A-Za-z0-9+/=]+$/); // Should start with "Basic " followed by base64
+    // Test with empty password
+    const encodedEmptyPass = encodeBasicAuthorizationHeader("user", "");
+    expect(encodedEmptyPass).toMatch(/^Basic [A-Za-z0-9+/=]+$/);
+    // Test with password containing special characters
+    const encodedSpecialChars = encodeBasicAuthorizationHeader("user", "p@ss!w0rd");
+    expect(encodedSpecialChars).toMatch(/^Basic [A-Za-z0-9+/=]+$/);
+    // Test with username containing colon should throw
+    expect(() => encodeBasicAuthorizationHeader("user:name", "pass")).toThrow();
+});

package/dist/utils/ips.js

@@ -2,8 +2,37 @@ import ipRegex from "ip-regex";
 export function isIpAddress(ip) {
     return ipRegex({ exact: true }).test(ip);
 }
+import.meta.vitest?.test("isIpAddress", ({ expect }) => {
+    // Test valid IPv4 addresses
+    expect(isIpAddress("192.168.1.1")).toBe(true);
+    expect(isIpAddress("127.0.0.1")).toBe(true);
+    expect(isIpAddress("0.0.0.0")).toBe(true);
+    expect(isIpAddress("255.255.255.255")).toBe(true);
+    // Test valid IPv6 addresses
+    expect(isIpAddress("::1")).toBe(true);
+    expect(isIpAddress("2001:db8::")).toBe(true);
+    expect(isIpAddress("2001:db8:85a3:8d3:1319:8a2e:370:7348")).toBe(true);
+    // Test invalid IP addresses
+    expect(isIpAddress("")).toBe(false);
+    expect(isIpAddress("not an ip")).toBe(false);
+    expect(isIpAddress("256.256.256.256")).toBe(false);
+    expect(isIpAddress("192.168.1")).toBe(false);
+    expect(isIpAddress("192.168.1.1.1")).toBe(false);
+    expect(isIpAddress("2001:db8::xyz")).toBe(false);
+});
 export function assertIpAddress(ip) {
     if (!isIpAddress(ip)) {
         throw new Error(`Invalid IP address: ${ip}`);
     }
 }
+import.meta.vitest?.test("assertIpAddress", ({ expect }) => {
+    // Test with valid IPv4 address
+    expect(() => assertIpAddress("192.168.1.1")).not.toThrow();
+    // Test with valid IPv6 address
+    expect(() => assertIpAddress("::1")).not.toThrow();
+    // Test with invalid IP addresses
+    expect(() => assertIpAddress("")).toThrow("Invalid IP address: ");
+    expect(() => assertIpAddress("not an ip")).toThrow("Invalid IP address: not an ip");
+    expect(() => assertIpAddress("256.256.256.256")).toThrow("Invalid IP address: 256.256.256.256");
+    expect(() => assertIpAddress("192.168.1")).toThrow("Invalid IP address: 192.168.1");
+});