@stackframe/stack-shared 2.3.3 → 2.3.6

package/dist/utils/caches.js

@@ -89,7 +89,9 @@ class AsyncValueCache {
         this._store.set(value);
     }
     _setAsync(value) {
-        return pending(this._store.setAsync(value));
+        const promise = pending(value);
+        this._pendingPromise = promise;
+        return pending(this._store.setAsync(promise));
     }
     _refetch(cacheStrategy) {
         if (cacheStrategy === "read-write" && this._pendingPromise) {
@@ -99,7 +101,6 @@ class AsyncValueCache {
         if (cacheStrategy === "never") {
             return promise;
         }
-        this._pendingPromise = promise;
         return pending(this._setAsync(promise).then(() => promise));
     }
     forceSetCachedValue(value) {

package/dist/utils/globals.d.ts

@@ -0,0 +1,3 @@
+declare const globalVar: any;
+export { globalVar, };
+export declare function createGlobal<T>(key: string, init: () => T): T;

package/dist/utils/globals.js

@@ -0,0 +1,14 @@
+const globalVar = typeof globalThis !== 'undefined' ? globalThis :
+    typeof window !== 'undefined' ? window :
+        typeof global !== 'undefined' ? global :
+            typeof self !== 'undefined' ? self :
+                {};
+export { globalVar, };
+const stackGlobalsSymbol = Symbol.for('__stack-globals');
+globalVar[stackGlobalsSymbol] ??= {};
+export function createGlobal(key, init) {
+    if (!globalVar[stackGlobalsSymbol][key]) {
+        globalVar[stackGlobalsSymbol][key] = init();
+    }
+    return globalVar[stackGlobalsSymbol][key];
+}

package/dist/utils/objects.d.ts

@@ -8,7 +8,7 @@ export type DeepPartial<T> = T extends object ? {
  */
 export declare function deepPlainEquals<T>(obj1: T, obj2: unknown): obj2 is T;
 export declare function typedEntries<T extends {}>(obj: T): [keyof T, T[keyof T]][];
-export declare function typedFromEntries<T extends {}>(entries: [keyof T, T[keyof T]][]): Partial<T>;
+export declare function typedFromEntries<K extends PropertyKey, V>(entries: [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): asserts target is T & U;

package/dist/utils/promises.d.ts

@@ -11,9 +11,7 @@ export declare function resolved<T>(value: T): ReactPromise<T>;
 /**
  * Like Promise.resolve(...), but also adds the status and value properties for use with React's `use` hook.
  */
-export declare function rejected<T>(reason: unknown, options?: {
-    disableErrorWrapping?: boolean;
-}): ReactPromise<T>;
+export declare function rejected<T>(reason: unknown): ReactPromise<T>;
 export declare function neverResolve(): ReactPromise<never>;
 export declare function pending<T>(promise: Promise<T>, options?: {
     disableErrorWrapping?: boolean;

package/dist/utils/promises.js

@@ -41,11 +41,10 @@ export function resolved(value) {
 /**
  * Like Promise.resolve(...), but also adds the status and value properties for use with React's `use` hook.
  */
-export function rejected(reason, options = {}) {
-    const actualReason = options.disableErrorWrapping ? reason : createReactPromiseErrorWrapper(reason);
-    return Object.assign(Promise.reject(actualReason), {
+export function rejected(reason) {
+    return Object.assign(Promise.reject(reason), {
         status: "rejected",
-        reason: actualReason,
+        reason: reason,
     });
 }
 export function neverResolve() {
@@ -58,27 +57,12 @@ export function pending(promise, options = {}) {
         return value;
     }, actualReason => {
         res.status = "rejected";
-        const reason = options.disableErrorWrapping ? actualReason : createReactPromiseErrorWrapper(actualReason);
-        res.reason = reason;
-        throw reason;
+        res.reason = actualReason;
+        throw actualReason;
     });
     res.status = "pending";
     return res;
 }
-function createReactPromiseErrorWrapper(error) {
-    return new ReactPromiseErrorWrapper(error);
-}
-class ReactPromiseErrorWrapper extends StackAssertionError {
-    error;
-    wrappedErrorMessage;
-    constructor(error) {
-        const wrappedErrorMessage = error instanceof ReactPromiseErrorWrapper ? error.wrappedErrorMessage : `${error}`;
-        super(`Error occured in a ReactPromise: ${wrappedErrorMessage}\n\nSee the \`cause\` property for the original error. This error is a wrapper around the original error to preserve the stack trace (which would go lost when using Stack's pending(...) or rejected(...) functions).`, { cause: error });
-        this.error = error;
-        this.wrappedErrorMessage = wrappedErrorMessage;
-        this.name = "ReactPromiseErrorWrapper";
-    }
-}
 export async function wait(ms) {
     return await new Promise(resolve => setTimeout(resolve, ms));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.3.3",
+  "version": "2.3.6",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [