@stackframe/stack-shared 2.7.20 → 2.7.22

package/dist/utils/json.js

@@ -18,9 +18,144 @@ export function isJson(value) {
         }
     }
 }
+import.meta.vitest?.test("isJson", ({ expect }) => {
+    // Test primitive values
+    expect(isJson(null)).toBe(true);
+    expect(isJson(true)).toBe(true);
+    expect(isJson(false)).toBe(true);
+    expect(isJson(123)).toBe(true);
+    expect(isJson("string")).toBe(true);
+    // Test arrays
+    expect(isJson([])).toBe(true);
+    expect(isJson([1, 2, 3])).toBe(true);
+    expect(isJson(["a", "b", "c"])).toBe(true);
+    expect(isJson([1, "a", true, null])).toBe(true);
+    expect(isJson([1, [2, 3], { a: "b" }])).toBe(true);
+    // Test objects
+    expect(isJson({})).toBe(true);
+    expect(isJson({ a: 1, b: 2 })).toBe(true);
+    expect(isJson({ a: "string", b: true, c: null })).toBe(true);
+    expect(isJson({ a: [1, 2, 3], b: { c: "d" } })).toBe(true);
+    // Test invalid JSON values
+    expect(isJson(undefined)).toBe(false);
+    expect(isJson(() => { })).toBe(false);
+    expect(isJson(Symbol())).toBe(false);
+    expect(isJson(BigInt(123))).toBe(false);
+    // Test arrays with invalid JSON values
+    expect(isJson([1, undefined, 3])).toBe(false);
+    expect(isJson([1, () => { }, 3])).toBe(false);
+    // Test objects with invalid JSON values
+    expect(isJson({ a: 1, b: undefined })).toBe(false);
+    expect(isJson({ a: 1, b: () => { } })).toBe(false);
+});
 export function parseJson(json) {
     return Result.fromThrowing(() => JSON.parse(json));
 }
+import.meta.vitest?.test("parseJson", ({ expect }) => {
+    // Test valid JSON strings
+    const nullResult = parseJson("null");
+    expect(nullResult.status).toBe("ok");
+    if (nullResult.status === "ok") {
+        expect(nullResult.data).toBe(null);
+    }
+    const trueResult = parseJson("true");
+    expect(trueResult.status).toBe("ok");
+    if (trueResult.status === "ok") {
+        expect(trueResult.data).toBe(true);
+    }
+    const numberResult = parseJson("123");
+    expect(numberResult.status).toBe("ok");
+    if (numberResult.status === "ok") {
+        expect(numberResult.data).toBe(123);
+    }
+    const stringResult = parseJson('"string"');
+    expect(stringResult.status).toBe("ok");
+    if (stringResult.status === "ok") {
+        expect(stringResult.data).toBe("string");
+    }
+    const emptyArrayResult = parseJson("[]");
+    expect(emptyArrayResult.status).toBe("ok");
+    if (emptyArrayResult.status === "ok") {
+        expect(emptyArrayResult.data).toEqual([]);
+    }
+    const arrayResult = parseJson("[1,2,3]");
+    expect(arrayResult.status).toBe("ok");
+    if (arrayResult.status === "ok") {
+        expect(arrayResult.data).toEqual([1, 2, 3]);
+    }
+    const emptyObjectResult = parseJson("{}");
+    expect(emptyObjectResult.status).toBe("ok");
+    if (emptyObjectResult.status === "ok") {
+        expect(emptyObjectResult.data).toEqual({});
+    }
+    const objectResult = parseJson('{"a":1,"b":"string"}');
+    expect(objectResult.status).toBe("ok");
+    if (objectResult.status === "ok") {
+        expect(objectResult.data).toEqual({ a: 1, b: "string" });
+    }
+    // Test invalid JSON strings
+    expect(parseJson("").status).toBe("error");
+    expect(parseJson("undefined").status).toBe("error");
+    expect(parseJson("{").status).toBe("error");
+    expect(parseJson('{"a":1,}').status).toBe("error");
+    expect(parseJson("function(){}").status).toBe("error");
+});
 export function stringifyJson(json) {
     return Result.fromThrowing(() => JSON.stringify(json));
 }
+import.meta.vitest?.test("stringifyJson", ({ expect }) => {
+    // Test primitive values
+    const nullResult = stringifyJson(null);
+    expect(nullResult.status).toBe("ok");
+    if (nullResult.status === "ok") {
+        expect(nullResult.data).toBe("null");
+    }
+    const trueResult = stringifyJson(true);
+    expect(trueResult.status).toBe("ok");
+    if (trueResult.status === "ok") {
+        expect(trueResult.data).toBe("true");
+    }
+    const numberResult = stringifyJson(123);
+    expect(numberResult.status).toBe("ok");
+    if (numberResult.status === "ok") {
+        expect(numberResult.data).toBe("123");
+    }
+    const stringResult = stringifyJson("string");
+    expect(stringResult.status).toBe("ok");
+    if (stringResult.status === "ok") {
+        expect(stringResult.data).toBe('"string"');
+    }
+    // Test arrays
+    const emptyArrayResult = stringifyJson([]);
+    expect(emptyArrayResult.status).toBe("ok");
+    if (emptyArrayResult.status === "ok") {
+        expect(emptyArrayResult.data).toBe("[]");
+    }
+    const arrayResult = stringifyJson([1, 2, 3]);
+    expect(arrayResult.status).toBe("ok");
+    if (arrayResult.status === "ok") {
+        expect(arrayResult.data).toBe("[1,2,3]");
+    }
+    // Test objects
+    const emptyObjectResult = stringifyJson({});
+    expect(emptyObjectResult.status).toBe("ok");
+    if (emptyObjectResult.status === "ok") {
+        expect(emptyObjectResult.data).toBe("{}");
+    }
+    const objectResult = stringifyJson({ a: 1, b: "string" });
+    expect(objectResult.status).toBe("ok");
+    if (objectResult.status === "ok") {
+        expect(objectResult.data).toBe('{"a":1,"b":"string"}');
+    }
+    // Test nested structures
+    const nested = { a: [1, 2, 3], b: { c: "d" } };
+    const nestedResult = stringifyJson(nested);
+    expect(nestedResult.status).toBe("ok");
+    if (nestedResult.status === "ok") {
+        expect(nestedResult.data).toBe('{"a":[1,2,3],"b":{"c":"d"}}');
+    }
+    // Test circular references (should error)
+    const circular = { a: 1 };
+    circular.self = circular;
+    expect(stringifyJson(circular).status).toBe("error");
+});

package/dist/utils/maps.js

@@ -13,6 +13,20 @@ export class WeakRefIfAvailable {
         return this._ref.deref();
     }
 }
+import.meta.vitest?.test("WeakRefIfAvailable", ({ expect }) => {
+    // Test with an object
+    const obj = { id: 1, name: "test" };
+    const weakRef = new WeakRefIfAvailable(obj);
+    // Test deref returns the original object
+    expect(weakRef.deref()).toBe(obj);
+    // Test with a different object
+    const obj2 = { id: 2, name: "test2" };
+    const weakRef2 = new WeakRefIfAvailable(obj2);
+    expect(weakRef2.deref()).toBe(obj2);
+    expect(weakRef2.deref()).not.toBe(obj);
+    // We can't easily test garbage collection in this environment,
+    // but we can verify the basic functionality works
+});
 /**
  * A WeakMap-like object that can be iterated over.
  *
@@ -62,6 +76,56 @@ export class IterableWeakMap {
     }
 }
 _a = Symbol.toStringTag;
+import.meta.vitest?.test("IterableWeakMap", ({ expect }) => {
+    // Test basic functionality
+    const map = new IterableWeakMap();
+    // Create object keys
+    const obj1 = { id: 1 };
+    const obj2 = { id: 2 };
+    // Test set and get
+    map.set(obj1, "value1");
+    expect(map.get(obj1)).toBe("value1");
+    // Test has
+    expect(map.has(obj1)).toBe(true);
+    expect(map.has(obj2)).toBe(false);
+    expect(map.has({ id: 1 })).toBe(false); // Different object with same content
+    // Test with multiple keys
+    map.set(obj2, "value2");
+    expect(map.get(obj2)).toBe("value2");
+    expect(map.get(obj1)).toBe("value1"); // Original still exists
+    // Test delete
+    expect(map.delete(obj1)).toBe(true);
+    expect(map.has(obj1)).toBe(false);
+    expect(map.get(obj1)).toBeUndefined();
+    expect(map.has(obj2)).toBe(true); // Other key still exists
+    // Test delete non-existent key
+    expect(map.delete({ id: 3 })).toBe(false);
+    // Test iteration
+    const iterMap = new IterableWeakMap();
+    const iterObj1 = { id: 1 };
+    const iterObj2 = { id: 2 };
+    const iterObj3 = { id: 3 };
+    iterMap.set(iterObj1, 1);
+    iterMap.set(iterObj2, 2);
+    iterMap.set(iterObj3, 3);
+    const entries = Array.from(iterMap);
+    expect(entries.length).toBe(3);
+    // Find entries by their values since we can't directly compare objects in the array
+    const values = entries.map(entry => entry[1]);
+    expect(values).toContain(1);
+    expect(values).toContain(2);
+    expect(values).toContain(3);
+    // Test constructor with entries
+    const initialEntries = [
+        [{ id: 4 }, "initial1"],
+        [{ id: 5 }, "initial2"]
+    ];
+    const mapWithEntries = new IterableWeakMap(initialEntries);
+    // We can't directly access the initial entries since they're different object references
+    // But we can verify the map has the correct number of entries
+    const entriesFromConstructor = Array.from(mapWithEntries);
+    expect(entriesFromConstructor.length).toBe(2);
+});
 /**
  * A map that is a IterableWeakMap for object keys and a regular Map for primitive keys. Also provides iteration over both
  * object and primitive keys.
@@ -117,6 +181,45 @@ export class MaybeWeakMap {
     }
 }
 _b = Symbol.toStringTag;
+import.meta.vitest?.test("MaybeWeakMap", ({ expect }) => {
+    // Test with primitive keys
+    const map = new MaybeWeakMap();
+    // Test with string keys
+    map.set("key1", 1);
+    map.set("key2", 2);
+    expect(map.get("key1")).toBe(1);
+    expect(map.get("key2")).toBe(2);
+    expect(map.has("key1")).toBe(true);
+    expect(map.has("nonexistent")).toBe(false);
+    // Test with object keys
+    const obj1 = { id: 1 };
+    const obj2 = { id: 2 };
+    map.set(obj1, 3);
+    map.set(obj2, 4);
+    expect(map.get(obj1)).toBe(3);
+    expect(map.get(obj2)).toBe(4);
+    expect(map.has(obj1)).toBe(true);
+    // Test delete with primitive key
+    expect(map.delete("key1")).toBe(true);
+    expect(map.has("key1")).toBe(false);
+    expect(map.delete("nonexistent")).toBe(false);
+    // Test delete with object key
+    expect(map.delete(obj1)).toBe(true);
+    expect(map.has(obj1)).toBe(false);
+    // Test iteration
+    const entries = Array.from(map);
+    expect(entries.length).toBe(2);
+    expect(entries).toContainEqual(["key2", 2]);
+    expect(entries).toContainEqual([obj2, 4]);
+    // Test constructor with entries
+    const initialEntries = [
+        ["initial1", 10],
+        [{ id: 3 }, 20]
+    ];
+    const mapWithEntries = new MaybeWeakMap(initialEntries);
+    expect(mapWithEntries.get("initial1")).toBe(10);
+    expect(mapWithEntries.get(initialEntries[1][0])).toBe(20);
+});
 /**
  * A map that stores values indexed by an array of keys. If the keys are objects and the environment supports WeakRefs,
  * they are stored in a WeakMap.
@@ -198,3 +301,45 @@ export class DependenciesMap {
     }
 }
 _c = Symbol.toStringTag;
+import.meta.vitest?.test("DependenciesMap", ({ expect }) => {
+    // Test basic functionality
+    const map = new DependenciesMap();
+    // Test set and get
+    map.set(["key", 1], "value1");
+    expect(map.get(["key", 1])).toBe("value1");
+    // Test has
+    expect(map.has(["key", 1])).toBe(true);
+    expect(map.has(["key", 2])).toBe(false);
+    // Test with different dependencies
+    map.set(["key", 2], "value2");
+    expect(map.get(["key", 2])).toBe("value2");
+    expect(map.get(["key", 1])).toBe("value1"); // Original still exists
+    // Test delete
+    expect(map.delete(["key", 1])).toBe(true);
+    expect(map.has(["key", 1])).toBe(false);
+    expect(map.get(["key", 1])).toBeUndefined();
+    expect(map.has(["key", 2])).toBe(true); // Other key still exists
+    // Test delete non-existent key
+    expect(map.delete(["nonexistent", 1])).toBe(false);
+    // Test clear
+    map.clear();
+    expect(map.has(["key", 2])).toBe(false);
+    // Test with object keys
+    const objMap = new DependenciesMap();
+    const obj1 = { id: 1 };
+    const obj2 = { id: 2 };
+    objMap.set([obj1, 1], "object1");
+    objMap.set([obj2, 2], "object2");
+    expect(objMap.get([obj1, 1])).toBe("object1");
+    expect(objMap.get([obj2, 2])).toBe("object2");
+    // Test iteration
+    const iterMap = new DependenciesMap();
+    iterMap.set(["a"], 1);
+    iterMap.set(["b"], 2);
+    iterMap.set(["c"], 3);
+    const entries = Array.from(iterMap);
+    expect(entries.length).toBe(3);
+    expect(entries).toContainEqual([["a"], 1]);
+    expect(entries).toContainEqual([["b"], 2]);
+    expect(entries).toContainEqual([["c"], 3]);
+});

package/dist/utils/objects.js

@@ -119,18 +119,87 @@ import.meta.vitest?.test("deepPlainClone", ({ expect }) => {
 export function typedEntries(obj) {
     return Object.entries(obj);
 }
+import.meta.vitest?.test("typedEntries", ({ expect }) => {
+    expect(typedEntries({})).toEqual([]);
+    expect(typedEntries({ a: 1, b: 2 })).toEqual([["a", 1], ["b", 2]]);
+    expect(typedEntries({ a: "hello", b: true, c: null })).toEqual([["a", "hello"], ["b", true], ["c", null]]);
+    // Test with object containing methods
+    const objWithMethod = { a: 1, b: () => "test" };
+    const entries = typedEntries(objWithMethod);
+    expect(entries.length).toBe(2);
+    expect(entries[0][0]).toBe("a");
+    expect(entries[0][1]).toBe(1);
+    expect(entries[1][0]).toBe("b");
+    expect(typeof entries[1][1]).toBe("function");
+});
 export function typedFromEntries(entries) {
     return Object.fromEntries(entries);
 }
+import.meta.vitest?.test("typedFromEntries", ({ expect }) => {
+    expect(typedFromEntries([])).toEqual({});
+    expect(typedFromEntries([["a", 1], ["b", 2]])).toEqual({ a: 1, b: 2 });
+    // Test with mixed types (using type assertion)
+    const mixedEntries = [["a", "hello"], ["b", true], ["c", null]];
+    const mixedObj = typedFromEntries(mixedEntries);
+    expect(mixedObj).toEqual({ a: "hello", b: true, c: null });
+    // Test with function values
+    const fn = () => "test";
+    const fnEntries = [["a", 1], ["b", fn]];
+    const obj = typedFromEntries(fnEntries);
+    expect(obj.a).toBe(1);
+    expect(typeof obj.b).toBe("function");
+    // Type assertion needed for the function call
+    expect(obj.b()).toBe("test");
+});
 export function typedKeys(obj) {
     return Object.keys(obj);
 }
+import.meta.vitest?.test("typedKeys", ({ expect }) => {
+    expect(typedKeys({})).toEqual([]);
+    expect(typedKeys({ a: 1, b: 2 })).toEqual(["a", "b"]);
+    expect(typedKeys({ a: "hello", b: true, c: null })).toEqual(["a", "b", "c"]);
+    // Test with object containing methods
+    const objWithMethod = { a: 1, b: () => "test" };
+    expect(typedKeys(objWithMethod)).toEqual(["a", "b"]);
+});
 export function typedValues(obj) {
     return Object.values(obj);
 }
+import.meta.vitest?.test("typedValues", ({ expect }) => {
+    expect(typedValues({})).toEqual([]);
+    expect(typedValues({ a: 1, b: 2 })).toEqual([1, 2]);
+    const mixedObj = { a: "hello", b: true, c: null };
+    expect(typedValues(mixedObj)).toEqual(["hello", true, null]);
+    const fn = () => "test";
+    const objWithMethod = { a: 1, b: fn };
+    const values = typedValues(objWithMethod);
+    expect(values.length).toBe(2);
+    expect(values[0]).toBe(1);
+    expect(typeof values[1]).toBe("function");
+    // Need to cast to the correct type
+    const fnValue = values[1];
+    expect(fnValue()).toBe("test");
+});
 export function typedAssign(target, source) {
     return Object.assign(target, source);
 }
+import.meta.vitest?.test("typedAssign", ({ expect }) => {
+    // Test with empty objects
+    const emptyTarget = {};
+    const emptyResult = typedAssign(emptyTarget, { a: 1 });
+    expect(emptyResult).toEqual({ a: 1 });
+    expect(emptyResult).toBe(emptyTarget); // Same reference
+    // Test with non-empty target
+    const target = { a: 1, b: 2 };
+    const result = typedAssign(target, { c: 3, d: 4 });
+    expect(result).toEqual({ a: 1, b: 2, c: 3, d: 4 });
+    expect(result).toBe(target); // Same reference
+    // Test with overlapping properties
+    const targetWithOverlap = { a: 1, b: 2 };
+    const resultWithOverlap = typedAssign(targetWithOverlap, { b: 3, c: 4 });
+    expect(resultWithOverlap).toEqual({ a: 1, b: 3, c: 4 });
+    expect(resultWithOverlap).toBe(targetWithOverlap); // Same reference
+});
 /**
  * Returns a new object with all undefined values removed. Useful when spreading optional parameters on an object, as
  * TypeScript's `Partial<XYZ>` type allows `undefined` values.