@stackframe/stack-shared 2.8.2 → 2.8.5

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

@@ -2,6 +2,9 @@ export declare function isNotNull<T>(value: T): value is NonNullable<T>;
 export type DeepPartial<T> = T extends object ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
+export type DeepRequired<T> = T extends object ? {
+    [P in keyof T]-?: DeepRequired<T[P]>;
+} : T;
 /**
  * Assumes both objects are primitives, arrays, or non-function plain objects, and compares them deeply.
  *
@@ -10,9 +13,16 @@ export type DeepPartial<T> = T extends object ? {
 export declare function deepPlainEquals<T>(obj1: T, obj2: unknown, options?: {
     ignoreUndefinedValues?: boolean;
 }): obj2 is T;
+export declare function isCloneable<T>(obj: T): obj is Exclude<T, symbol | Function>;
+export declare function shallowClone<T extends object>(obj: T): T;
 export declare function deepPlainClone<T>(obj: T): T;
+export type DeepMerge<T, U> = Omit<T, keyof U> & Omit<U, keyof T> & DeepMergeInner<Pick<T, keyof U & keyof T>, Pick<U, keyof U & keyof T>>;
+type DeepMergeInner<T, U> = {
+    [K in keyof U]-?: undefined extends U[K] ? K extends keyof T ? T[K] extends object ? Exclude<U[K], undefined> extends object ? DeepMerge<T[K], Exclude<U[K], undefined>> : T[K] | Exclude<U[K], undefined> : T[K] | Exclude<U[K], undefined> : Exclude<U[K], undefined> : K extends keyof T ? T[K] extends object ? U[K] extends object ? DeepMerge<T[K], U[K]> : U[K] : U[K] : U[K];
+};
+export declare function deepMerge<T extends {}, U extends {}>(baseObj: T, mergeObj: U): DeepMerge<T, U>;
 export declare function typedEntries<T extends {}>(obj: T): [keyof T, T[keyof T]][];
-export declare function typedFromEntries<K extends PropertyKey, V>(entries: [K, V][]): Record<K, V>;
+export declare function typedFromEntries<K extends PropertyKey, V>(entries: (readonly [K, V])[]): Record<K, V>;
 export declare function typedKeys<T extends {}>(obj: T): (keyof T)[];
 export declare function typedValues<T extends {}>(obj: T): T[keyof T][];
 export declare function typedAssign<T extends {}, U extends {}>(target: T, source: U): T & U;
@@ -25,7 +35,30 @@ export type FilterUndefined<T> = {
  * 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.
  */
-export declare function filterUndefined<T extends {}>(obj: T): FilterUndefined<T>;
+export declare function filterUndefined<T extends object>(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 object>(obj: T): FilterUndefinedOrNull<T>;
+export type DeepFilterUndefined<T> = T extends object ? FilterUndefined<{
+    [K in keyof T]: DeepFilterUndefined<T[K]>;
+}> : T;
+export declare function deepFilterUndefined<T extends object>(obj: T): DeepFilterUndefined<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>];
+export declare function set<T extends object, K extends keyof T>(obj: T, key: K, value: T[K]): void;
+export declare function get<T extends object, K extends keyof T>(obj: T, key: K): T[K];
+export declare function has<T extends object, K extends keyof T>(obj: T, key: K): obj is T & {
+    [k in K]: unknown;
+};
+export declare function hasAndNotUndefined<T extends object, K extends keyof T>(obj: T, key: K): obj is T & {
+    [k in K]: Exclude<T[K], undefined>;
+};
+export declare function deleteKey<T extends object, K extends keyof T>(obj: T, key: K): void;
+export declare function isObjectLike(value: unknown): value is object;
+export {};

package/dist/utils/objects.js

@@ -1,4 +1,5 @@
 import { StackAssertionError } from "./errors";
+import { identity } from "./functions";
 export function isNotNull(value) {
     return value !== null && value !== undefined;
 }
@@ -78,6 +79,21 @@ import.meta.vitest?.test("deepPlainEquals", ({ expect }) => {
     expect(deepPlainEquals({ a: 1, b: undefined }, { a: 1 }, { ignoreUndefinedValues: true })).toBe(true);
     expect(deepPlainEquals({ a: 1, b: undefined }, { a: 1 })).toBe(false);
 });
+export function isCloneable(obj) {
+    return typeof obj !== 'symbol' && typeof obj !== 'function';
+}
+export function shallowClone(obj) {
+    if (!isCloneable(obj))
+        throw new StackAssertionError("shallowClone does not support symbols or functions", { obj });
+    if (Array.isArray(obj))
+        return obj.map(identity);
+    return { ...obj };
+}
+import.meta.vitest?.test("shallowClone", ({ expect }) => {
+    expect(shallowClone({ a: 1, b: 2 })).toEqual({ a: 1, b: 2 });
+    expect(shallowClone([1, 2, 3])).toEqual([1, 2, 3]);
+    expect(() => shallowClone(() => { })).toThrow();
+});
 export function deepPlainClone(obj) {
     if (typeof obj === 'function')
         throw new StackAssertionError("deepPlainClone does not support functions");
@@ -116,6 +132,75 @@ import.meta.vitest?.test("deepPlainClone", ({ expect }) => {
     expect(() => deepPlainClone(() => { })).toThrow();
     expect(() => deepPlainClone(Symbol())).toThrow();
 });
+export function deepMerge(baseObj, mergeObj) {
+    if ([baseObj, mergeObj, ...Object.values(baseObj), ...Object.values(mergeObj)].some(o => !isCloneable(o)))
+        throw new StackAssertionError("deepMerge does not support functions or symbols", { baseObj, mergeObj });
+    const res = shallowClone(baseObj);
+    for (const [key, mergeValue] of Object.entries(mergeObj)) {
+        if (has(res, key)) {
+            const baseValue = get(res, key);
+            if (isObjectLike(baseValue) && isObjectLike(mergeValue)) {
+                set(res, key, deepMerge(baseValue, mergeValue));
+                continue;
+            }
+        }
+        set(res, key, mergeValue);
+    }
+    return res;
+}
+import.meta.vitest?.test("deepMerge", ({ expect }) => {
+    // Test merging flat objects
+    expect(deepMerge({ a: 1 }, { b: 2 })).toEqual({ a: 1, b: 2 });
+    expect(deepMerge({ a: 1 }, { a: 2 })).toEqual({ a: 2 });
+    expect(deepMerge({ a: 1, b: 2 }, { b: 3, c: 4 })).toEqual({ a: 1, b: 3, c: 4 });
+    // Test with nested objects
+    expect(deepMerge({ a: { x: 1, y: 2 }, b: 3 }, { a: { y: 3, z: 4 }, c: 5 })).toEqual({ a: { x: 1, y: 3, z: 4 }, b: 3, c: 5 });
+    // Test with arrays
+    expect(deepMerge({ a: [1, 2], b: 3 }, { a: [3, 4], c: 5 })).toEqual({ a: [3, 4], b: 3, c: 5 });
+    // Test with null values
+    expect(deepMerge({ a: { x: 1 }, b: null }, { a: { y: 2 }, b: { z: 3 } })).toEqual({ a: { x: 1, y: 2 }, b: { z: 3 } });
+    // Test with undefined values
+    expect(deepMerge({ a: 1, b: undefined }, { b: 2, c: 3 })).toEqual({ a: 1, b: 2, c: 3 });
+    // Test deeply nested structures
+    expect(deepMerge({
+        a: {
+            x: { deep: 1 },
+            y: [1, 2]
+        },
+        b: 2
+    }, {
+        a: {
+            x: { deeper: 3 },
+            y: [3, 4]
+        },
+        c: 3
+    })).toEqual({
+        a: {
+            x: { deep: 1, deeper: 3 },
+            y: [3, 4]
+        },
+        b: 2,
+        c: 3
+    });
+    // Test with empty objects
+    expect(deepMerge({}, { a: 1 })).toEqual({ a: 1 });
+    expect(deepMerge({ a: 1 }, {})).toEqual({ a: 1 });
+    expect(deepMerge({}, {})).toEqual({});
+    // Test that original objects are not modified
+    const base = { a: { x: 1 }, b: 2 };
+    const merge = { a: { y: 2 }, c: 3 };
+    const baseClone = deepPlainClone(base);
+    const mergeClone = deepPlainClone(merge);
+    const result = deepMerge(base, merge);
+    expect(base).toEqual(baseClone);
+    expect(merge).toEqual(mergeClone);
+    expect(result).toEqual({ a: { x: 1, y: 2 }, b: 2, c: 3 });
+    // Test error cases
+    expect(() => deepMerge({ a: () => { } }, { b: 2 })).toThrow();
+    expect(() => deepMerge({ a: 1 }, { b: () => { } })).toThrow();
+    expect(() => deepMerge({ a: Symbol() }, { b: 2 })).toThrow();
+    expect(() => deepMerge({ a: 1 }, { b: Symbol() })).toThrow();
+});
 export function typedEntries(obj) {
     return Object.entries(obj);
 }
@@ -215,6 +300,23 @@ 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 deepFilterUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined).map(([k, v]) => [k, isObjectLike(v) ? deepFilterUndefined(v) : v]));
+}
+import.meta.vitest?.test("deepFilterUndefined", ({ expect }) => {
+    expect(deepFilterUndefined({ a: 1, b: undefined })).toEqual({ a: 1 });
+});
 export function pick(obj, keys) {
     return Object.fromEntries(Object.entries(obj).filter(([k]) => keys.includes(k)));
 }
@@ -248,3 +350,29 @@ import.meta.vitest?.test("split", ({ expect }) => {
     // Use type assertion for empty object to avoid TypeScript error
     expect(split({}, ["a"])).toEqual([{}, {}]);
 });
+export function set(obj, key, value) {
+    Object.defineProperty(obj, key, { value, writable: true, configurable: true, enumerable: true });
+}
+export function get(obj, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+    if (!descriptor)
+        throw new StackAssertionError(`get: key ${String(key)} does not exist`, { obj, key });
+    return descriptor.value;
+}
+export function has(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+export function hasAndNotUndefined(obj, key) {
+    return has(obj, key) && get(obj, key) !== undefined;
+}
+export function deleteKey(obj, key) {
+    if (has(obj, key)) {
+        Reflect.deleteProperty(obj, key);
+    }
+    else {
+        throw new StackAssertionError(`deleteKey: key ${String(key)} does not exist`, { obj, key });
+    }
+}
+export function isObjectLike(value) {
+    return (typeof value === 'object' || typeof value === 'function') && value !== null;
+}

package/dist/utils/promises.d.ts

@@ -31,7 +31,7 @@ export declare function pending<T>(promise: Promise<T>, options?: {
  *
  * Vercel kills serverless functions on unhandled promise rejection errors, so this is important.
  */
-export declare function ignoreUnhandledRejection<T extends Promise<any>>(promise: T): T;
+export declare function ignoreUnhandledRejection<T extends Promise<any>>(promise: T): void;
 export declare function wait(ms: number): Promise<void>;
 export declare function waitUntil(date: Date): Promise<void>;
 export declare function runAsynchronouslyWithAlert(...args: Parameters<typeof runAsynchronously>): void;

package/dist/utils/promises.js

@@ -114,7 +114,9 @@ export function rejected(reason) {
     if (rejectedCache.has([reason])) {
         return rejectedCache.get([reason]);
     }
-    const res = Object.assign(ignoreUnhandledRejection(Promise.reject(reason)), {
+    const promise = Promise.reject(reason);
+    ignoreUnhandledRejection(promise);
+    const res = Object.assign(promise, {
         status: "rejected",
         reason: reason,
     });
@@ -191,22 +193,19 @@ import.meta.vitest?.test("pending", async ({ expect }) => {
  */
 export function ignoreUnhandledRejection(promise) {
     promise.catch(() => { });
-    return promise;
 }
 import.meta.vitest?.test("ignoreUnhandledRejection", async ({ expect }) => {
     // Test with a promise that resolves
     const resolvePromise = Promise.resolve(42);
-    const ignoredResolvePromise = ignoreUnhandledRejection(resolvePromise);
-    expect(ignoredResolvePromise).toBe(resolvePromise); // Should return the same promise
-    expect(await ignoredResolvePromise).toBe(42); // Should still resolve to the same value
+    ignoreUnhandledRejection(resolvePromise);
+    expect(await resolvePromise).toBe(42); // Should still resolve to the same value
     // Test with a promise that rejects
-    const error = new Error("Test error");
-    const rejectPromise = Promise.reject(error);
-    const ignoredRejectPromise = ignoreUnhandledRejection(rejectPromise);
-    expect(ignoredRejectPromise).toBe(rejectPromise); // Should return the same promise
     // The promise should still reject, but the rejection is caught internally
     // so it doesn't cause an unhandled rejection error
-    await expect(ignoredRejectPromise).rejects.toBe(error);
+    const error = new Error("Test error");
+    const rejectPromise = Promise.reject(error);
+    ignoreUnhandledRejection(rejectPromise);
+    await expect(rejectPromise).rejects.toBe(error);
 });
 export async function wait(ms) {
     if (!Number.isFinite(ms) || ms < 0) {

package/dist/utils/stores.d.ts

@@ -60,6 +60,12 @@ export declare class AsyncStore<T> implements ReadonlyAsyncStore<T> {
     isAvailable(): boolean;
     isRejected(): boolean;
     get(): ({
+        status: "pending";
+    } & {
+        progress: void;
+    } & {
+        status: "pending";
+    }) | ({
         status: "error";
         error: unknown;
     } & {
@@ -69,12 +75,6 @@ export declare class AsyncStore<T> implements ReadonlyAsyncStore<T> {
         data: T;
     } & {
         status: "ok";
-    }) | ({
-        status: "pending";
-    } & {
-        progress: void;
-    } & {
-        status: "pending";
     });
     getOrWait(): ReactPromise<T>;
     _setIfLatest(result: Result<T>, curCounter: number): boolean;

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> = T extends object ? {
+    [K in keyof T]: T[K];
+} & {} : T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.8.2",
+  "version": "2.8.5",
   "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",