@stackframe/stack-shared 2.3.2 → 2.3.5

package/dist/utils/caches.d.ts

@@ -34,6 +34,7 @@ export declare class AsyncCache<D extends any[], T> {
     });
     readonly getOrWait: (key: D, cacheStrategy: CacheStrategy) => ReactPromise<T>;
     readonly forceSetCachedValue: (key: D, value: T) => void;
+    readonly forceSetCachedValueAsync: (key: D, value: Promise<T>) => ReactPromise<boolean>;
     readonly refresh: (key: D) => Promise<T>;
     readonly invalidate: (key: D) => Promise<T>;
     readonly onChange: (key: D, callback: (value: T, oldValue: T | undefined) => void) => {
@@ -75,6 +76,7 @@ declare class AsyncValueCache<T> {
     private _setAsync;
     private _refetch;
     forceSetCachedValue(value: T): void;
+    forceSetCachedValueAsync(value: Promise<T>): ReactPromise<boolean>;
     refresh(): Promise<T>;
     invalidate(): Promise<T>;
     onChange(callback: (value: T, oldValue: T | undefined) => void): {

package/dist/utils/caches.js

@@ -46,6 +46,7 @@ export class AsyncCache {
     getIfCached = this._createKeyed("getIfCached");
     getOrWait = this._createKeyed("getOrWait");
     forceSetCachedValue = this._createKeyed("forceSetCachedValue");
+    forceSetCachedValueAsync = this._createKeyed("forceSetCachedValueAsync");
     refresh = this._createKeyed("refresh");
     invalidate = this._createKeyed("invalidate");
     onChange = this._createKeyed("onChange");
@@ -88,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) {
@@ -98,12 +101,14 @@ class AsyncValueCache {
         if (cacheStrategy === "never") {
             return promise;
         }
-        this._pendingPromise = promise;
         return pending(this._setAsync(promise).then(() => promise));
     }
     forceSetCachedValue(value) {
         this._set(value);
     }
+    forceSetCachedValueAsync(value) {
+        return this._setAsync(value);
+    }
     async refresh() {
         return await this.getOrWait("write-only");
     }

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 while creating 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/dist/utils/results.d.ts

@@ -58,7 +58,7 @@ declare function pending(): AsyncResult<never, never, void> & {
 declare function pending<P>(progress: P): AsyncResult<never, never, P> & {
     status: "pending";
 };
-declare function promiseToResult<T, E = unknown>(promise: Promise<T>): Promise<Result<T, E>>;
+declare function promiseToResult<T>(promise: Promise<T>): Promise<Result<T>>;
 declare function fromThrowing<T>(fn: () => T): Result<T, unknown>;
 declare function mapResult<T, U, E = unknown, P = unknown>(result: Result<T, E>, fn: (data: T) => U): Result<U, E>;
 declare function mapResult<T, U, E = unknown, P = unknown>(result: AsyncResult<T, E, P>, fn: (data: T) => U): AsyncResult<U, E, P>;

package/dist/utils/results.js

@@ -53,14 +53,14 @@ function pending(progress) {
         progress: progress,
     };
 }
-function promiseToResult(promise) {
-    return promise.then(data => ({
-        status: "ok",
-        data,
-    }), error => ({
-        status: "error",
-        error,
-    }));
+async function promiseToResult(promise) {
+    try {
+        const value = await promise;
+        return Result.ok(value);
+    }
+    catch (error) {
+        return Result.error(error);
+    }
 }
 function fromThrowing(fn) {
     try {

package/package.json

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