@stackframe/stack-shared 2.8.3 → 2.8.6

package/dist/schema-fields.d.ts

@@ -5,8 +5,8 @@ declare module "yup" {
         empty(): StringSchema<TType, TContext, TDefault, TFlags>;
     }
     interface Schema<TType, TContext, TDefault, TFlags> {
-        getNested<K extends keyof TType>(path: K): yup.Schema<TType[K], TContext, TDefault, TFlags>;
-        concat<U extends yup.AnySchema>(schema: U): yup.Schema<Omit<TType, keyof yup.InferType<U>> & yup.InferType<U>, TContext, TDefault, TFlags>;
+        getNested<K extends keyof NonNullable<TType>>(path: K): yup.Schema<NonNullable<TType>[K], TContext, TDefault, TFlags>;
+        concat<U extends yup.AnySchema>(schema: U): yup.Schema<Omit<NonNullable<TType>, keyof yup.InferType<U>> & yup.InferType<U> | (TType & (null | undefined)), TContext, TDefault, TFlags>;
     }
 }
 export declare function yupValidate<S extends yup.ISchema<any>>(schema: S, obj: unknown, options?: yup.ValidateOptions & {
@@ -27,6 +27,7 @@ export declare function yupTuple<T extends [unknown, ...unknown[]]>(...args: Par
 export declare function yupObject<A extends yup.Maybe<yup.AnyObject>, B extends yup.ObjectShape>(...args: Parameters<typeof yup.object<A, B>>): yup.ObjectSchema<yup.TypeFromShape<B, yup.AnyObject> extends infer T ? T extends yup.TypeFromShape<B, yup.AnyObject> ? T extends {} ? { [k in keyof T]: T[k]; } : T : never : never, yup.AnyObject, yup.DefaultFromShape<B> extends infer T_1 ? T_1 extends yup.DefaultFromShape<B> ? T_1 extends {} ? { [k_1 in keyof T_1]: T_1[k_1]; } : T_1 : never : never, "">;
 export declare function yupNever(): yup.MixedSchema<never>;
 export declare function yupUnion<T extends yup.ISchema<any>[]>(...args: T): yup.MixedSchema<yup.InferType<T[number]>>;
+export declare function yupRecord<K extends yup.StringSchema, T extends yup.AnySchema>(keySchema: K, valueSchema: T): yup.MixedSchema<Record<string, yup.InferType<T>>>;
 export declare function ensureObjectSchema<T extends yup.AnyObject>(schema: yup.Schema<T>): yup.ObjectSchema<T> & typeof schema;
 export declare const adaptSchema: yup.MixedSchema<typeof StackAdaptSentinel | undefined, yup.AnyObject, undefined, "">;
 /**
@@ -65,7 +66,7 @@ export declare const projectClientTeamCreationEnabledSchema: yup.BooleanSchema<b
 export declare const projectClientUserDeletionEnabledSchema: yup.BooleanSchema<boolean | undefined, yup.AnyObject, undefined, "">;
 export declare const projectSignUpEnabledSchema: yup.BooleanSchema<boolean | undefined, yup.AnyObject, undefined, "">;
 export declare const projectCredentialEnabledSchema: yup.BooleanSchema<boolean | undefined, yup.AnyObject, undefined, "">;
-export declare const oauthIdSchema: yup.StringSchema<"google" | "github" | "microsoft" | "spotify" | "facebook" | "discord" | "gitlab" | "bitbucket" | "linkedin" | "apple" | "x" | undefined, yup.AnyObject, undefined, "">;
+export declare const oauthIdSchema: yup.StringSchema<"apple" | "x" | "google" | "github" | "microsoft" | "spotify" | "facebook" | "discord" | "gitlab" | "bitbucket" | "linkedin" | undefined, yup.AnyObject, undefined, "">;
 export declare const oauthEnabledSchema: yup.BooleanSchema<boolean | undefined, yup.AnyObject, undefined, "">;
 export declare const oauthTypeSchema: yup.StringSchema<"shared" | "standard" | undefined, yup.AnyObject, undefined, "">;
 export declare const oauthClientIdSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
@@ -99,7 +100,7 @@ export declare const userClientReadOnlyMetadataSchema: yup.MixedSchema<{} | null
 export declare const userServerMetadataSchema: yup.MixedSchema<{} | null, yup.AnyObject, undefined, "">;
 export declare const userOAuthProviderSchema: yup.ObjectSchema<{
     id: string;
-    type: "google" | "github" | "microsoft" | "spotify" | "facebook" | "discord" | "gitlab" | "bitbucket" | "linkedin" | "apple" | "x";
+    type: "apple" | "x" | "google" | "github" | "microsoft" | "spotify" | "facebook" | "discord" | "gitlab" | "bitbucket" | "linkedin";
     provider_user_id: string;
 }, yup.AnyObject, {
     id: undefined;

package/dist/schema-fields.js

@@ -118,9 +118,9 @@ export function yupObject(...args) {
                 if (unknownKeys.length > 0) {
                     // TODO "did you mean XYZ"
                     return context.createError({
-                        message: `${context.path} contains unknown properties: ${unknownKeys.join(', ')}`,
+                        message: `${context.path || "Object"} contains unknown properties: ${unknownKeys.join(', ')}`,
                         path: context.path,
-                        params: { unknownKeys },
+                        params: { unknownKeys, availableKeys },
                     });
                 }
             }
@@ -160,6 +160,38 @@ export function yupUnion(...args) {
         });
     });
 }
+export function yupRecord(keySchema, valueSchema) {
+    return yupObject().unknown(true).test('record', '${path} must be a record of valid values', async function (value, context) {
+        if (value == null)
+            return true;
+        const { path, createError } = this;
+        if (typeof value !== 'object') {
+            return createError({ message: `${path} must be an object` });
+        }
+        // Validate each property using the provided valueSchema
+        for (const key of Object.keys(value)) {
+            // Validate the key
+            await yupValidate(keySchema, key, context.options);
+            // Validate the value
+            try {
+                await yupValidate(valueSchema, value[key], {
+                    ...context.options,
+                    context: {
+                        ...context.options.context,
+                        path: path ? `${path}.${key}` : key,
+                    },
+                });
+            }
+            catch (e) {
+                return createError({
+                    path: path ? `${path}.${key}` : key,
+                    message: e.message,
+                });
+            }
+        }
+        return true;
+    });
+}
 export function ensureObjectSchema(schema) {
     if (!(schema instanceof yup.ObjectSchema))
         throw new StackAssertionError(`assertObjectSchema: schema is not an ObjectSchema: ${schema.describe().type}`);
@@ -216,9 +248,36 @@ export const passwordSchema = yupString().max(70);
  * `emailSchema` instead until we do the DB migration.
  */
 // eslint-disable-next-line no-restricted-syntax
-export const strictEmailSchema = (message) => yupString().email(message).matches(/^[^.].*@.*\.[^.][^.]+$/, message);
+export const strictEmailSchema = (message) => yupString().email(message).matches(/^[^.]+(\.[^.]+)*@.*\.[^.][^.]+$/, message);
 // eslint-disable-next-line no-restricted-syntax
 export const emailSchema = yupString().email();
+import.meta.vitest?.test('strictEmailSchema', ({ expect }) => {
+    const validEmails = [
+        "a@example.com",
+        "abc@example.com",
+        "a.b@example.com",
+        "throwaway.mail+token@example.com",
+        "email-alt-dash@demo-mail.com",
+        "test-account@weird-domain.net",
+        "%!~&+{}=|`#@domain.test",
+        "admin@a.longtldexample",
+    ];
+    for (const email of validEmails) {
+        expect(strictEmailSchema(undefined).validateSync(email)).toBe(email);
+    }
+    const invalidEmails = [
+        "test@localhost",
+        "test@gmail",
+        "test@gmail.com.a",
+        "test@gmail.a",
+        "test.@example.com",
+        "test..test@example.com",
+        ".test@example.com",
+    ];
+    for (const email of invalidEmails) {
+        expect(() => strictEmailSchema(undefined).validateSync(email)).toThrow();
+    }
+});
 // Request auth
 export const clientOrHigherAuthTypeSchema = yupString().oneOf(['client', 'server', 'admin']).defined();
 export const serverOrHigherAuthTypeSchema = yupString().oneOf(['server', 'admin']).defined();

package/dist/utils/api-keys.js

@@ -8,7 +8,8 @@ const API_KEY_LENGTHS = {
     SECRET_PART: 45,
     ID_PART: 32,
     TYPE_PART: 4,
-    SCANNER_AND_MARKER: 10,
+    SCANNER: 1,
+    MARKER: 9,
     CHECKSUM: 8,
 };
 function createChecksumSync(checksummablePart) {
@@ -27,22 +28,22 @@ function createApiKeyParts(options) {
     return { checksummablePart, idPart, prefix, scannerAndMarker, type };
 }
 function parseApiKeyParts(secret) {
-    const regex = new RegExp(`^([^_]+)_` + // prefix
-        `(.{${API_KEY_LENGTHS.SECRET_PART}})` + // secretPart
-        `(.{${API_KEY_LENGTHS.ID_PART}})` + // idPart
-        `(.{${API_KEY_LENGTHS.TYPE_PART}})` + // type
-        `(.{${API_KEY_LENGTHS.SCANNER_AND_MARKER}})` + // scannerAndMarker
-        `(.{${API_KEY_LENGTHS.CHECKSUM}})$` // checksum
+    const regex = new RegExp(`^([a-zA-Z0-9_]+)_` + // prefix
+        `([a-zA-Z0-9_]{${API_KEY_LENGTHS.SECRET_PART}})` + // secretPart
+        `([a-zA-Z0-9_]{${API_KEY_LENGTHS.ID_PART}})` + // idPart
+        `([a-zA-Z0-9_]{${API_KEY_LENGTHS.TYPE_PART}})` + // type
+        `([a-zA-Z0-9_]{${API_KEY_LENGTHS.SCANNER}})` + // scanner
+        `(${STACK_AUTH_MARKER})` + // marker
+        `([a-zA-Z0-9_]{${API_KEY_LENGTHS.CHECKSUM}})$` // checksum
     );
     const match = secret.match(regex);
     if (!match) {
         throw new StackAssertionError("Invalid API key format");
     }
-    const [, prefix, secretPart, idPart, type, scannerAndMarker, checksum] = match;
-    const scannerFlag = scannerAndMarker.replace(STACK_AUTH_MARKER, "");
+    const [, prefix, secretPart, idPart, type, scannerFlag, marker, checksum] = match;
     const isCloudVersion = parseInt(scannerFlag, 32) % 2 === 0;
     const isPublic = (parseInt(scannerFlag, 32) & 2) !== 0;
-    const checksummablePart = `${prefix}_${secretPart}${idPart}${type}${scannerAndMarker}`;
+    const checksummablePart = `${prefix}_${secretPart}${idPart}${type}${scannerFlag}${marker}`;
     const restored_id = idPart.replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
     if (!["user", "team"].includes(type)) {
         throw new StackAssertionError("Invalid type");

package/dist/utils/caches.d.ts

@@ -17,16 +17,16 @@ export declare class AsyncCache<D extends any[], T> {
     refreshWhere(predicate: (dependencies: D) => boolean): Promise<void>;
     readonly isCacheAvailable: (key: D) => boolean;
     readonly getIfCached: (key: D) => ({
-        status: "error";
-        error: unknown;
-    } & {
-        status: "error";
-    }) | ({
         status: "pending";
     } & {
         progress: void;
     } & {
         status: "pending";
+    }) | ({
+        status: "error";
+        error: unknown;
+    } & {
+        status: "error";
     }) | ({
         status: "ok";
         data: T;
@@ -57,16 +57,16 @@ declare class AsyncValueCache<T> {
     });
     isCacheAvailable(): boolean;
     getIfCached(): ({
-        status: "error";
-        error: unknown;
-    } & {
-        status: "error";
-    }) | ({
         status: "pending";
     } & {
         progress: void;
     } & {
         status: "pending";
+    }) | ({
+        status: "error";
+        error: unknown;
+    } & {
+        status: "error";
     }) | ({
         status: "ok";
         data: T;

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,7 @@ 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];
 }>;
@@ -33,7 +43,22 @@ export type FilterUndefinedOrNull<T> = FilterUndefined<{
  * 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 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);
 }
@@ -226,6 +311,12 @@ 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)));
 }
@@ -259,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

@@ -16,6 +16,6 @@ export type IfAndOnlyIf<Value, Extends, Then, Otherwise> = (Value extends Extend
 /**
  * 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> = {
+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.3",
+  "version": "2.8.6",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",