@stackframe/stack-shared 2.8.1 → 2.8.3

package/dist/utils/errors.js

@@ -68,11 +68,7 @@ StackAssertionError.prototype.name = "StackAssertionError";
 export function errorToNiceString(error) {
     if (!(error instanceof Error))
         return `${typeof error}<${nicify(error)}>`;
-    let stack = error.stack ?? "";
-    const toString = error.toString();
-    if (!stack.startsWith(toString))
-        stack = `${toString}\n${stack}`; // some browsers don't include the error message in the stack, some do
-    return `${stack} ${nicify(Object.fromEntries(Object.entries(error)), { maxDepth: 8 })}`;
+    return nicify(error, { maxDepth: 8 });
 }
 const errorSinks = new Set();
 export function registerErrorSink(sink) {

package/dist/utils/hashes.d.ts

@@ -1,4 +1,4 @@
-export declare function sha512(input: Uint8Array | string): Promise<string>;
+export declare function sha512(input: Uint8Array | string): Promise<Uint8Array>;
 export declare function hashPassword(password: string): Promise<string>;
 export declare function comparePassword(password: string, hash: string): Promise<boolean>;
 export declare function isPasswordHashValid(hash: string): Promise<boolean>;

package/dist/utils/hashes.js

@@ -2,9 +2,7 @@ import bcrypt from 'bcrypt';
 import { StackAssertionError } from './errors';
 export async function sha512(input) {
     const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
-    return await crypto.subtle.digest("SHA-512", bytes).then(buf => {
-        return Array.prototype.map.call(new Uint8Array(buf), x => (('00' + x.toString(16)).slice(-2))).join('');
-    });
+    return new Uint8Array(await crypto.subtle.digest("SHA-512", bytes));
 }
 export async function hashPassword(password) {
     const passwordBytes = new TextEncoder().encode(password);

package/dist/utils/objects.d.ts

@@ -26,6 +26,14 @@ export type FilterUndefined<T> = {
  * TypeScript's `Partial<XYZ>` type allows `undefined` values.
  */
 export declare function filterUndefined<T extends {}>(obj: T): FilterUndefined<T>;
+export type FilterUndefinedOrNull<T> = FilterUndefined<{
+    [k in keyof T]: null extends T[k] ? NonNullable<T[k]> | undefined : T[k];
+}>;
+/**
+ * Returns a new object with all undefined and null values removed. Useful when spreading optional parameters on an object, as
+ * TypeScript's `Partial<XYZ>` type allows `undefined` values.
+ */
+export declare function filterUndefinedOrNull<T extends {}>(obj: T): FilterUndefinedOrNull<T>;
 export declare function pick<T extends {}, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
 export declare function omit<T extends {}, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
 export declare function split<T extends {}, K extends keyof T>(obj: T, keys: K[]): [Pick<T, K>, Omit<T, K>];

package/dist/utils/objects.js

@@ -215,6 +215,17 @@ import.meta.vitest?.test("filterUndefined", ({ expect }) => {
     expect(filterUndefined({ a: null, b: undefined })).toEqual({ a: null });
     expect(filterUndefined({ a: 0, b: "", c: false, d: undefined })).toEqual({ a: 0, b: "", c: false });
 });
+/**
+ * Returns a new object with all undefined and null values removed. Useful when spreading optional parameters on an object, as
+ * TypeScript's `Partial<XYZ>` type allows `undefined` values.
+ */
+export function filterUndefinedOrNull(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined && v !== null));
+}
+import.meta.vitest?.test("filterUndefinedOrNull", ({ expect }) => {
+    expect(filterUndefinedOrNull({})).toEqual({});
+    expect(filterUndefinedOrNull({ a: 1, b: 2 })).toEqual({ a: 1, b: 2 });
+});
 export function pick(obj, keys) {
     return Object.fromEntries(Object.entries(obj).filter(([k]) => keys.includes(k)));
 }

package/dist/utils/results.js

@@ -1,5 +1,5 @@
 import { wait } from "./promises";
-import { deindent } from "./strings";
+import { deindent, nicify } from "./strings";
 export const Result = {
     fromThrowing,
     fromThrowingAsync,
@@ -255,17 +255,17 @@ import.meta.vitest?.test("mapResult", ({ expect }) => {
 });
 class RetryError extends AggregateError {
     constructor(errors) {
-        const strings = errors.map(e => String(e));
+        const strings = errors.map(e => nicify(e));
         const isAllSame = strings.length > 1 && strings.every(s => s === strings[0]);
         super(errors, deindent `
       Error after ${errors.length} attempts.
       
       ${isAllSame ? deindent `
         Attempts 1-${errors.length}:
-          ${errors[0]}
-      ` : errors.map((e, i) => deindent `
+          ${strings[0]}
+      ` : strings.map((s, i) => deindent `
           Attempt ${i + 1}:
-            ${e}
+            ${s}
         `).join("\n\n")}
       `, { cause: errors[errors.length - 1] });
         this.errors = errors;

package/dist/utils/strings.d.ts

@@ -43,6 +43,7 @@ export declare function trimLines(s: string): string;
 export declare function templateIdentity(strings: TemplateStringsArray | readonly string[], ...values: string[]): string;
 export declare function deindent(code: string): string;
 export declare function deindent(strings: TemplateStringsArray | readonly string[], ...values: any[]): string;
+export declare function deindentTemplate(strings: TemplateStringsArray | readonly string[], ...values: any[]): [string[], ...string[]];
 export declare function extractScopes(scope: string, removeDuplicates?: boolean): string[];
 export declare function mergeScopeStrings(...scopes: string[]): string;
 export declare function escapeTemplateLiteral(s: string): string;

package/dist/utils/strings.js

@@ -207,8 +207,9 @@ Line2`).toBe("Line1\nLine2");
 export function deindent(strings, ...values) {
     if (typeof strings === "string")
         return deindent([strings]);
-    if (strings.length === 0)
-        return "";
+    return templateIdentity(...deindentTemplate(strings, ...values));
+}
+export function deindentTemplate(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];
@@ -231,7 +232,7 @@ export function deindent(strings, ...values) {
         const firstLineIndentation = getWhitespacePrefix(deindentedStrings[i].split("\n").at(-1));
         return `${value}`.replaceAll("\n", `\n${firstLineIndentation}`);
     });
-    return templateIdentity(deindentedStrings, ...indentedValues);
+    return [deindentedStrings, ...indentedValues];
 }
 import.meta.vitest?.test("deindent", ({ expect }) => {
     // Test with string input
@@ -241,7 +242,6 @@ import.meta.vitest?.test("deindent", ({ expect }) => {
     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
@@ -414,12 +414,13 @@ export function nicify(value, options = {}) {
         keyInParent: null,
         hideFields: [],
     };
-    const nestedNicify = (newValue, newPath, keyInParent) => {
+    const nestedNicify = (newValue, newPath, keyInParent, options = {}) => {
         return nicify(newValue, {
             ...newOptions,
             path: newPath,
             currentIndent: currentIndent + lineIndent,
             keyInParent,
+            ...options,
         });
     };
     switch (typeof value) {
@@ -431,7 +432,7 @@ export function nicify(value, options = {}) {
             const isDeindentable = (v) => deindent(v) === v && v.includes("\n");
             const wrapInDeindent = (v) => deindent `
         deindent\`
-        ${currentIndent + lineIndent}${escapeTemplateLiteral(value).replaceAll("\n", nl + lineIndent)}
+        ${currentIndent + lineIndent}${escapeTemplateLiteral(v).replaceAll("\n", nl + lineIndent)}
         ${currentIndent}\`
       `;
             if (isDeindentable(value)) {
@@ -470,7 +471,7 @@ export function nicify(value, options = {}) {
                 resValues.push(...extraLines);
                 if (resValues.length !== resValueLength)
                     throw new StackAssertionError("nicify of object: resValues.length !== resValueLength", { value, resValues, resValueLength });
-                const shouldIndent = resValues.length > 1 || resValues.some(x => x.includes("\n"));
+                const shouldIndent = resValues.length > 4 || resValues.some(x => (resValues.length > 1 && x.length > 4) || x.includes("\n"));
                 if (shouldIndent) {
                     return `[${nl}${resValues.map(x => `${lineIndent}${x},${nl}`).join("")}]`;
                 }
@@ -479,13 +480,30 @@ export function nicify(value, options = {}) {
                 }
             }
             if (value instanceof URL) {
-                return `URL(${nicify(value.toString())})`;
+                return `URL(${nestedNicify(value.toString(), `${path}.toString()`, null)})`;
             }
             if (ArrayBuffer.isView(value)) {
                 return `${value.constructor.name}([${value.toString()}])`;
             }
+            if (value instanceof Error) {
+                let stack = value.stack ?? "";
+                const toString = value.toString();
+                if (!stack.startsWith(toString))
+                    stack = `${toString}\n${stack}`; // some browsers don't include the error message in the stack, some do
+                stack = stack.trimEnd();
+                stack = stack.replace(/\n\s+/g, `\n${lineIndent}${lineIndent}`);
+                stack = stack.replace("\n", `\n${lineIndent}Stack:\n`);
+                if (Object.keys(value).length > 0) {
+                    stack += `\n${lineIndent}Extra properties: ${nestedNicify(Object.fromEntries(Object.entries(value)), path, null)}`;
+                }
+                if (value.cause) {
+                    stack += `\n${lineIndent}Cause:\n${lineIndent}${lineIndent}${nestedNicify(value.cause, path, null, { currentIndent: currentIndent + lineIndent + lineIndent })}`;
+                }
+                stack = stack.replaceAll("\n", `\n${currentIndent}`);
+                return stack;
+            }
             const constructorName = [null, Object.prototype].includes(Object.getPrototypeOf(value)) ? null : (nicifiableClassNameOverrides.get(value.constructor) ?? value.constructor.name);
-            const constructorString = constructorName ? `${nicifyPropertyString(constructorName)} ` : "";
+            const constructorString = constructorName ? `${constructorName} ` : "";
             const entries = getNicifiableEntries(value).filter(([k]) => !hideFields.includes(k));
             const extraLines = [
                 ...getNicifiedObjectExtraLines(value),
@@ -498,7 +516,7 @@ export function nicify(value, options = {}) {
                 return `${constructorString}{ ... }`;
             const resValues = entries.map(([k, v], keyIndex) => {
                 const keyNicified = nestedNicify(k, `Object.keys(${path})[${keyIndex}]`, null);
-                const keyInObjectLiteral = typeof k === "string" ? JSON.stringify(k) : `[${keyNicified}]`;
+                const keyInObjectLiteral = typeof k === "string" ? nicifyPropertyString(k) : `[${keyNicified}]`;
                 if (typeof v === "function" && v.name === k) {
                     return `${keyInObjectLiteral}(...): { ... }`;
                 }
@@ -525,25 +543,63 @@ export function nicify(value, options = {}) {
     }
 }
 export function replaceAll(input, searchValue, replaceValue) {
+    if (searchValue === "")
+        throw new StackAssertionError("replaceAll: searchValue is empty");
     return input.split(searchValue).join(replaceValue);
 }
+import.meta.vitest?.test("replaceAll", ({ expect }) => {
+    expect(replaceAll("hello world", "o", "x")).toBe("hellx wxrld");
+    expect(replaceAll("aaa", "a", "b")).toBe("bbb");
+    expect(replaceAll("", "a", "b")).toBe("");
+    expect(replaceAll("abc", "b", "")).toBe("ac");
+    expect(replaceAll("test.test.test", ".", "_")).toBe("test_test_test");
+    expect(replaceAll("a.b*c", ".", "x")).toBe("axb*c");
+    expect(replaceAll("a*b*c", "*", "x")).toBe("axbxc");
+    expect(replaceAll("hello hello", "hello", "hi")).toBe("hi hi");
+});
 function nicifyPropertyString(str) {
-    if (/^[_a-zA-Z][_a-zA-Z0-9]*$/.test(str))
-        return str;
     return JSON.stringify(str);
 }
+import.meta.vitest?.test("nicifyPropertyString", ({ expect }) => {
+    // Test valid identifiers
+    expect(nicifyPropertyString("validName")).toBe('"validName"');
+    expect(nicifyPropertyString("_validName")).toBe('"_validName"');
+    expect(nicifyPropertyString("valid123Name")).toBe('"valid123Name"');
+    // Test invalid identifiers
+    expect(nicifyPropertyString("123invalid")).toBe('"123invalid"');
+    expect(nicifyPropertyString("invalid-name")).toBe('"invalid-name"');
+    expect(nicifyPropertyString("invalid space")).toBe('"invalid space"');
+    expect(nicifyPropertyString("$invalid")).toBe('"$invalid"');
+    expect(nicifyPropertyString("")).toBe('""');
+    // Test with special characters
+    expect(nicifyPropertyString("property!")).toBe('"property!"');
+    expect(nicifyPropertyString("property.name")).toBe('"property.name"');
+    // Test with escaped characters
+    expect(nicifyPropertyString("\\")).toBe('"\\\\"');
+    expect(nicifyPropertyString('"')).toBe('"\\""');
+});
 function getNicifiableKeys(value) {
     const overridden = ("getNicifiableKeys" in value ? value.getNicifiableKeys?.bind(value) : null)?.();
     if (overridden != null)
         return overridden;
     const keys = Object.keys(value).sort();
-    if (value instanceof Error) {
-        if (value.cause)
-            keys.unshift("cause");
-        keys.unshift("message", "stack");
-    }
     return unique(keys);
 }
+import.meta.vitest?.test("getNicifiableKeys", ({ expect }) => {
+    // Test regular object
+    expect(getNicifiableKeys({ b: 1, a: 2, c: 3 })).toEqual(["a", "b", "c"]);
+    // Test empty object
+    expect(getNicifiableKeys({})).toEqual([]);
+    // Test object with custom getNicifiableKeys
+    const customObject = {
+        a: 1,
+        b: 2,
+        getNicifiableKeys() {
+            return ["customKey1", "customKey2"];
+        }
+    };
+    expect(getNicifiableKeys(customObject)).toEqual(["customKey1", "customKey2"]);
+});
 function getNicifiableEntries(value) {
     const recordLikes = [Headers];
     function isRecordLike(value) {

package/dist/utils/strings.nicify.test.js

@@ -0,0 +1,214 @@
+import { describe, expect, test } from "vitest";
+import { deindent, nicify } from "./strings";
+describe("nicify", () => {
+    describe("primitive values", () => {
+        test("numbers", () => {
+            expect(nicify(123)).toBe("123");
+            expect(nicify(123n)).toBe("123n");
+        });
+        test("strings", () => {
+            expect(nicify("hello")).toBe('"hello"');
+        });
+        test("booleans", () => {
+            expect(nicify(true)).toBe("true");
+            expect(nicify(false)).toBe("false");
+        });
+        test("null and undefined", () => {
+            expect(nicify(null)).toBe("null");
+            expect(nicify(undefined)).toBe("undefined");
+        });
+        test("symbols", () => {
+            expect(nicify(Symbol("test"))).toBe("Symbol(test)");
+        });
+    });
+    describe("arrays", () => {
+        test("empty array", () => {
+            expect(nicify([])).toBe("[]");
+        });
+        test("single-element array", () => {
+            expect(nicify([1])).toBe("[1]");
+        });
+        test("single-element array with long content", () => {
+            expect(nicify(["123123123123123"])).toBe('["123123123123123"]');
+        });
+        test("flat array", () => {
+            expect(nicify([1, 2, 3])).toBe("[1, 2, 3]");
+        });
+        test("longer array", () => {
+            expect(nicify([10000, 2, 3])).toBe(deindent `
+        [
+          10000,
+          2,
+          3,
+        ]
+      `);
+        });
+        test("nested array", () => {
+            expect(nicify([1, [2, 3]])).toBe(deindent `
+        [
+          1,
+          [2, 3],
+        ]
+      `);
+        });
+    });
+    describe("objects", () => {
+        test("empty object", () => {
+            expect(nicify({})).toBe("{}");
+        });
+        test("simple object", () => {
+            expect(nicify({ a: 1 })).toBe('{ "a": 1 }');
+        });
+        test("multiline object", () => {
+            expect(nicify({ a: 1, b: 2 })).toBe(deindent `
+        {
+          "a": 1,
+          "b": 2,
+        }
+      `);
+        });
+    });
+    describe("custom classes", () => {
+        test("class instance", () => {
+            class TestClass {
+                constructor(value) {
+                    this.value = value;
+                }
+            }
+            expect(nicify(new TestClass(42))).toBe('TestClass { "value": 42 }');
+        });
+    });
+    describe("built-in objects", () => {
+        test("URL", () => {
+            expect(nicify(new URL("https://example.com"))).toBe('URL("https://example.com/")');
+        });
+        test("TypedArrays", () => {
+            expect(nicify(new Uint8Array([1, 2, 3]))).toBe("Uint8Array([1,2,3])");
+            expect(nicify(new Int32Array([1, 2, 3]))).toBe("Int32Array([1,2,3])");
+        });
+        test("Error objects", () => {
+            const error = new Error("test error");
+            const nicifiedError = nicify({ error });
+            expect(nicifiedError).toMatch(new RegExp(deindent `
+        ^\{
+          "error": Error: test error
+            Stack:
+              at (.|\\n)*
+        \}$
+      `));
+        });
+        test("Error objects with cause and an extra property", () => {
+            const error = new Error("test error", { cause: new Error("cause") });
+            error.extra = "something";
+            const nicifiedError = nicify(error, { lineIndent: "--" });
+            expect(nicifiedError).toMatch(new RegExp(deindent `
+        ^Error: test error
+        --Stack:
+        ----at (.|\\n)+
+        --Extra properties: \{ "extra": "something" \}
+        --Cause:
+        ----Error: cause
+        ------Stack:
+        --------at (.|\\n)+$
+      `));
+        });
+        test("Headers", () => {
+            const headers = new Headers();
+            headers.append("Content-Type", "application/json");
+            headers.append("Accept", "text/plain");
+            expect(nicify(headers)).toBe(deindent `
+        Headers {
+          "accept": "text/plain",
+          "content-type": "application/json",
+        }`);
+        });
+    });
+    describe("multiline strings", () => {
+        test("basic multiline", () => {
+            expect(nicify("line1\nline2")).toBe('deindent`\n  line1\n  line2\n`');
+        });
+        test("multiline with trailing newline", () => {
+            expect(nicify("line1\nline2\n")).toBe('deindent`\n  line1\n  line2\n` + "\\n"');
+        });
+    });
+    describe("circular references", () => {
+        test("object with self reference", () => {
+            const circular = { a: 1 };
+            circular.self = circular;
+            expect(nicify(circular)).toBe(deindent `
+        {
+          "a": 1,
+          "self": Ref<value>,
+        }`);
+        });
+    });
+    describe("configuration options", () => {
+        test("maxDepth", () => {
+            const deep = { a: { b: { c: { d: { e: 1 } } } } };
+            expect(nicify(deep, { maxDepth: 2 })).toBe('{ "a": { "b": { ... } } }');
+        });
+        test("lineIndent", () => {
+            expect(nicify({ a: 1, b: 2 }, { lineIndent: "    " })).toBe(deindent `
+        {
+            "a": 1,
+            "b": 2,
+        }
+      `);
+        });
+        test("hideFields", () => {
+            expect(nicify({ a: 1, b: 2, secret: "hidden" }, { hideFields: ["secret"] })).toBe(deindent `
+        {
+          "a": 1,
+          "b": 2,
+          <some fields may have been hidden>,
+        }
+      `);
+        });
+    });
+    describe("custom overrides", () => {
+        test("override with custom type", () => {
+            expect(nicify({ type: "special" }, {
+                overrides: ((value) => {
+                    if (typeof value === "object" && value && "type" in value && value.type === "special") {
+                        return "SPECIAL";
+                    }
+                    return null;
+                })
+            })).toBe("SPECIAL");
+        });
+    });
+    describe("functions", () => {
+        test("named function", () => {
+            expect(nicify(function namedFunction() { })).toBe("function namedFunction(...) { ... }");
+        });
+        test("arrow function", () => {
+            expect(nicify(() => { })).toBe("(...) => { ... }");
+        });
+    });
+    describe("Nicifiable interface", () => {
+        test("object implementing Nicifiable", () => {
+            const nicifiable = {
+                value: 42,
+                getNicifiableKeys() {
+                    return ["value"];
+                },
+                getNicifiedObjectExtraLines() {
+                    return ["// custom comment"];
+                }
+            };
+            expect(nicify(nicifiable)).toBe(deindent `
+        {
+          "value": 42,
+          // custom comment,
+        }
+      `);
+        });
+    });
+    describe("unknown types", () => {
+        test("object without prototype", () => {
+            const unknownType = Object.create(null);
+            unknownType.value = "test";
+            expect(nicify(unknownType)).toBe('{ "value": "test" }');
+        });
+    });
+});

package/dist/utils/types.d.ts

@@ -2,3 +2,20 @@ export type IsAny<T> = 0 extends (1 & T) ? true : false;
 export type isNullish<T> = T extends null | undefined ? true : false;
 export type NullishCoalesce<T, U> = T extends null | undefined ? U : T;
 export type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
+/**
+ * A variation of TypeScript's conditionals with slightly different semantics. It is the perfect type for cases where:
+ *
+ * - If all possible values are contained in `Extends`, then it will be mapped to `Then`.
+ * - If all possible values are not contained in `Extends`, then it will be mapped to `Otherwise`.
+ * - If some possible values are contained in `Extends` and some are not, then it will be mapped to `Then | Otherwise`.
+ *
+ * This is different from TypeScript's built-in conditional types (`Value extends Extends ? Then : Otherwise`), which
+ * returns `Otherwise` for the third case (causing unsoundness in many real-world cases).
+ */
+export type IfAndOnlyIf<Value, Extends, Then, Otherwise> = (Value extends Extends ? never : Otherwise) | (Value & Extends extends never ? never : Then);
+/**
+ * Can be used to prettify a type in the IDE; for example, some complicated intersected types can be flattened into a single type.
+ */
+export type PrettifyType<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.8.1",
+  "version": "2.8.3",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
@@ -45,6 +45,7 @@
     "@simplewebauthn/browser": "^11.0.0",
     "async-mutex": "^0.5.0",
     "bcrypt": "^5.1.1",
+    "crc": "^4.3.2",
     "elliptic": "^6.5.7",
     "ip-regex": "^5.0.0",
     "jose": "^5.2.2",

package/dist/utils/strings.test.js

@@ -1,26 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { templateIdentity } from "./strings";
-describe("templateIdentity", () => {
-    it("should be equivalent to a regular template string", () => {
-        const adjective = "scientific";
-        const noun = "railgun";
-        expect(templateIdentity `a certain scientific railgun`).toBe("a certain scientific railgun");
-        expect(templateIdentity `a certain ${adjective} railgun`).toBe(`a certain scientific railgun`);
-        expect(templateIdentity `a certain ${adjective} ${noun}`).toBe(`a certain scientific railgun`);
-        expect(templateIdentity `${adjective}${noun}`).toBe(`scientificrailgun`);
-    });
-    it("should work with empty strings", () => {
-        expect(templateIdentity ``).toBe("");
-        expect(templateIdentity `${""}`).toBe("");
-        expect(templateIdentity `${""}${""}`).toBe("");
-    });
-    it("should work with normal arrays", () => {
-        expect(templateIdentity(["a ", " scientific ", "gun"], "certain", "rail")).toBe("a certain scientific railgun");
-        expect(templateIdentity(["a"])).toBe("a");
-    });
-    it("should throw an error with wrong number of value arguments", () => {
-        expect(() => templateIdentity([])).toThrow();
-        expect(() => templateIdentity(["a", "b"])).toThrow();
-        expect(() => templateIdentity(["a", "b", "c"], "a", "b", "c")).toThrow();
-    });
-});