@stackframe/stack-shared 2.5.2 → 2.5.4

package/dist/utils/numbers.js

@@ -1,9 +1,9 @@
 const magnitudes = [
-    [1_000_000_000_000_000, "trln"],
-    [1_000_000_000_000, "bln"],
-    [1_000_000_000, "bn"],
-    [1_000_000, "M"],
-    [1_000, "k"],
+    [1000000000000000, "trln"],
+    [1000000000000, "bln"],
+    [1000000000, "bn"],
+    [1000000, "M"],
+    [1000, "k"],
 ];
 export function prettyPrintWithMagnitudes(num) {
     if (typeof num !== "number")

package/dist/utils/objects.d.ts

@@ -6,7 +6,9 @@ export type DeepPartial<T> = T extends object ? {
  *
  * Note that since they are assumed to be plain objects, this function does not compare prototypes.
  */
-export declare function deepPlainEquals<T>(obj1: T, obj2: unknown): obj2 is T;
+export declare function deepPlainEquals<T>(obj1: T, obj2: unknown, options?: {
+    ignoreUndefinedValues?: boolean;
+}): obj2 is T;
 export declare function deepPlainClone<T>(obj: T): T;
 export declare function deepPlainSnakeCaseToCamelCase(snakeCaseObj: any): any;
 export declare function deepPlainCamelCaseToSnakeCase(camelCaseObj: any): any;
@@ -27,3 +29,4 @@ export type FilterUndefined<T> = {
 export declare function filterUndefined<T extends {}>(obj: T): FilterUndefined<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

@@ -5,7 +5,7 @@ import { camelCaseToSnakeCase, snakeCaseToCamelCase } from "./strings";
  *
  * Note that since they are assumed to be plain objects, this function does not compare prototypes.
  */
-export function deepPlainEquals(obj1, obj2) {
+export function deepPlainEquals(obj1, obj2, options = {}) {
     if (typeof obj1 !== typeof obj2)
         return false;
     if (obj1 === obj2)
@@ -19,13 +19,18 @@ export function deepPlainEquals(obj1, obj2) {
                     return false;
                 if (obj1.length !== obj2.length)
                     return false;
-                return obj1.every((v, i) => deepPlainEquals(v, obj2[i]));
+                return obj1.every((v, i) => deepPlainEquals(v, obj2[i], options));
             }
-            const keys1 = Object.keys(obj1);
-            const keys2 = Object.keys(obj2);
-            if (keys1.length !== keys2.length)
+            const entries1 = Object.entries(obj1).filter(([k, v]) => !options.ignoreUndefinedValues || v !== undefined);
+            const entries2 = Object.entries(obj2).filter(([k, v]) => !options.ignoreUndefinedValues || v !== undefined);
+            if (entries1.length !== entries2.length)
                 return false;
-            return keys1.every((k) => k in obj2 && deepPlainEquals(obj1[k], obj2[k]));
+            return entries1.every(([k, v1]) => {
+                const e2 = entries2.find(([k2]) => k === k2);
+                if (!e2)
+                    return false;
+                return deepPlainEquals(v1, e2[1], options);
+            });
         }
         case 'undefined':
         case 'string':
@@ -58,7 +63,7 @@ export function deepPlainSnakeCaseToCamelCase(snakeCaseObj) {
     if (typeof snakeCaseObj !== 'object' || !snakeCaseObj)
         return snakeCaseObj;
     if (Array.isArray(snakeCaseObj))
-        return snakeCaseObj.map(deepPlainSnakeCaseToCamelCase);
+        return snakeCaseObj.map(o => deepPlainSnakeCaseToCamelCase(o));
     return Object.fromEntries(Object.entries(snakeCaseObj).map(([k, v]) => [snakeCaseToCamelCase(k), deepPlainSnakeCaseToCamelCase(v)]));
 }
 export function deepPlainCamelCaseToSnakeCase(camelCaseObj) {
@@ -67,7 +72,7 @@ export function deepPlainCamelCaseToSnakeCase(camelCaseObj) {
     if (typeof camelCaseObj !== 'object' || !camelCaseObj)
         return camelCaseObj;
     if (Array.isArray(camelCaseObj))
-        return camelCaseObj.map(deepPlainCamelCaseToSnakeCase);
+        return camelCaseObj.map(o => deepPlainCamelCaseToSnakeCase(o));
     return Object.fromEntries(Object.entries(camelCaseObj).map(([k, v]) => [camelCaseToSnakeCase(k), deepPlainCamelCaseToSnakeCase(v)]));
 }
 export function typedEntries(obj) {
@@ -98,3 +103,6 @@ export function pick(obj, keys) {
 export function omit(obj, keys) {
     return Object.fromEntries(Object.entries(obj).filter(([k]) => !keys.includes(k)));
 }
+export function split(obj, keys) {
+    return [pick(obj, keys), omit(obj, keys)];
+}

package/dist/utils/promises.js

@@ -118,7 +118,6 @@ export function runAsynchronously(promiseOrFunc, options = {}) {
     });
 }
 class TimeoutError extends Error {
-    ms;
     constructor(ms) {
         super(`Timeout after ${ms}ms`);
         this.ms = ms;
@@ -160,7 +159,12 @@ export function rateLimited(func, options) {
         const end = performance.now();
         waitUntil = Math.max(waitUntil, start + (options.throttleMs ?? 0), end + (options.gapMs ?? 0));
         for (const nextFunc of nextFuncs) {
-            value.status === "ok" ? nextFunc[0](value.data) : nextFunc[1](value.error);
+            if (value.status === "ok") {
+                nextFunc[0](value.data);
+            }
+            else {
+                nextFunc[1](value.error);
+            }
         }
     };
     runAsynchronously(async () => {

package/dist/utils/proxies.d.ts

@@ -1 +1,2 @@
 export declare function logged<T extends object>(name: string, toLog: T, options?: {}): T;
+export declare function createLazyProxy<FactoryResult>(factory: () => FactoryResult): FactoryResult;

package/dist/utils/proxies.js

@@ -57,3 +57,68 @@ export function logged(name, toLog, options = {}) {
     });
     return proxy;
 }
+export function createLazyProxy(factory) {
+    let cache = undefined;
+    let initialized = false;
+    function initializeIfNeeded() {
+        if (!initialized) {
+            cache = factory();
+            initialized = true;
+        }
+        return cache;
+    }
+    return new Proxy({}, {
+        get(target, prop, receiver) {
+            const instance = initializeIfNeeded();
+            return Reflect.get(instance, prop, receiver);
+        },
+        set(target, prop, value, receiver) {
+            const instance = initializeIfNeeded();
+            return Reflect.set(instance, prop, value, receiver);
+        },
+        has(target, prop) {
+            const instance = initializeIfNeeded();
+            return Reflect.has(instance, prop);
+        },
+        deleteProperty(target, prop) {
+            const instance = initializeIfNeeded();
+            return Reflect.deleteProperty(instance, prop);
+        },
+        ownKeys(target) {
+            const instance = initializeIfNeeded();
+            return Reflect.ownKeys(instance);
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            const instance = initializeIfNeeded();
+            return Reflect.getOwnPropertyDescriptor(instance, prop);
+        },
+        defineProperty(target, prop, descriptor) {
+            const instance = initializeIfNeeded();
+            return Reflect.defineProperty(instance, prop, descriptor);
+        },
+        getPrototypeOf(target) {
+            const instance = initializeIfNeeded();
+            return Reflect.getPrototypeOf(instance);
+        },
+        setPrototypeOf(target, proto) {
+            const instance = initializeIfNeeded();
+            return Reflect.setPrototypeOf(instance, proto);
+        },
+        isExtensible(target) {
+            const instance = initializeIfNeeded();
+            return Reflect.isExtensible(instance);
+        },
+        preventExtensions(target) {
+            const instance = initializeIfNeeded();
+            return Reflect.preventExtensions(instance);
+        },
+        apply(target, thisArg, argumentsList) {
+            const instance = initializeIfNeeded();
+            return Reflect.apply(instance, thisArg, argumentsList);
+        },
+        construct(target, argumentsList, newTarget) {
+            const instance = initializeIfNeeded();
+            return Reflect.construct(instance, argumentsList, newTarget);
+        }
+    });
+}

package/dist/utils/react.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import React from "react";
 export declare function getNodeText(node: React.ReactNode): string;
 /**
  * Suspends the currently rendered component indefinitely. Will not unsuspend unless the component rerenders.

package/dist/utils/react.js

@@ -1,4 +1,4 @@
-import { use } from "react";
+import React from "react";
 import { neverResolve } from "./promises";
 import { deindent } from "./strings";
 import { isBrowserLike } from "./env";
@@ -23,7 +23,7 @@ export function getNodeText(node) {
  * You can use this to translate older query- or AsyncResult-based code to new the Suspense system, for example: `if (query.isLoading) suspend();`
  */
 export function suspend() {
-    use(neverResolve());
+    React.use(neverResolve());
     throw new Error("Somehow a Promise that never resolves was resolved?");
 }
 /**

package/dist/utils/results.js

@@ -85,7 +85,6 @@ function mapResult(result, fn) {
     return Result.ok(fn(result.data));
 }
 class RetryError extends AggregateError {
-    errors;
     constructor(errors) {
         super(errors, deindent `
       Error after retrying ${errors.length} times.

package/dist/utils/stores.js

@@ -2,10 +2,9 @@ import { AsyncResult, Result } from "./results";
 import { generateUuid } from "./uuids";
 import { pending, rejected, resolved } from "./promises";
 export class Store {
-    _value;
-    _callbacks = new Map();
     constructor(_value) {
         this._value = _value;
+        this._callbacks = new Map();
     }
     get() {
         return this._value;
@@ -38,15 +37,13 @@ export class Store {
     }
 }
 export class AsyncStore {
-    _isAvailable;
-    _mostRecentOkValue = undefined;
-    _isRejected = false;
-    _rejectionError;
-    _waitingRejectFunctions = new Map();
-    _callbacks = new Map();
-    _updateCounter = 0;
-    _lastSuccessfulUpdate = -1;
     constructor(...args) {
+        this._mostRecentOkValue = undefined;
+        this._isRejected = false;
+        this._waitingRejectFunctions = new Map();
+        this._callbacks = new Map();
+        this._updateCounter = 0;
+        this._lastSuccessfulUpdate = -1;
         if (args.length === 0) {
             this._isAvailable = false;
         }

package/dist/utils/strings.js

@@ -1,3 +1,4 @@
+import { findLastIndex } from "./arrays";
 import { StackAssertionError } from "./errors";
 import { filterUndefined } from "./objects";
 export function typedToLowercase(s) {
@@ -42,7 +43,7 @@ export function trimEmptyLinesStart(s) {
  */
 export function trimEmptyLinesEnd(s) {
     const lines = s.split("\n");
-    const lastNonEmptyLineIndex = lines.findLastIndex((line) => line.trim() !== "");
+    const lastNonEmptyLineIndex = findLastIndex(lines, (line) => line.trim() !== "");
     return lines.slice(0, lastNonEmptyLineIndex + 1).join("\n");
 }
 /**
@@ -105,9 +106,13 @@ export function mergeScopeStrings(...scopes) {
     return extractScopes(allScope).join(" ");
 }
 export function snakeCaseToCamelCase(snakeCase) {
+    if (snakeCase.match(/[A-Z]/))
+        return snakeCase; // TODO next-release: this is a hack for fixing the email templates, remove this after v2 migration
     return snakeCase.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
 }
 export function camelCaseToSnakeCase(camelCase) {
+    if (camelCase.match(/_/))
+        return camelCase; // TODO next-release: this is a hack for fixing the email templates, remove this after v2 migration
     return camelCase.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
 /**
@@ -251,7 +256,7 @@ function nicifyPropertyString(str) {
     return JSON.stringify(str);
 }
 function getNicifiableKeys(value) {
-    return ("getNicifiableKeys" in value ? value.getNicifiableKeys : null)?.() ?? Object.keys(value).sort();
+    return ("getNicifiableKeys" in value ? value.getNicifiableKeys?.bind(value) : null)?.() ?? Object.keys(value).sort();
 }
 function getNicifiableEntries(value) {
     const recordLikes = [Headers];

package/dist/utils/urls.d.ts

@@ -0,0 +1 @@
+export declare function isLocalhost(urlOrString: string | URL): boolean;

package/dist/utils/urls.js

@@ -0,0 +1,8 @@
+export function isLocalhost(urlOrString) {
+    const url = new URL(urlOrString);
+    if (url.hostname === "localhost" || url.hostname.endsWith(".localhost"))
+        return true;
+    if (url.hostname.match(/^127\.\d+\.\d+\.\d+$/))
+        return true;
+    return false;
+}

package/dist/utils/uuids.d.ts

@@ -1 +1 @@
-export declare function generateUuid(): any;
+export declare function generateUuid(): string;

package/dist/utils/uuids.js

@@ -1,4 +1,5 @@
 import { globalVar } from "./globals";
 export function generateUuid() {
-    return globalVar.crypto.randomUUID();
+    // crypto.randomUuid is not supported in all browsers, so this is a polyfill
+    return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, c => (+c ^ globalVar.crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.5.2",
+  "version": "2.5.4",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -36,7 +36,7 @@
     "jose": "^5.2.2",
     "oauth4webapi": "^2.10.3",
     "uuid": "^9.0.1",
-    "@stackframe/stack-sc": "2.5.2"
+    "@stackframe/stack-sc": "2.5.4"
   },
   "devDependencies": {
     "rimraf": "^5.0.5",

package/dist/utils/yup.d.ts

@@ -1,3 +0,0 @@
-import * as yup from "yup";
-export declare const yupJson: yup.MixedSchema<{} | null, yup.AnyObject, undefined, "">;
-export declare const yupJsonValidator: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;

package/dist/utils/yup.js

@@ -1,13 +0,0 @@
-import * as yup from "yup";
-export const yupJson = yup.mixed().nullable().defined().transform((value) => JSON.parse(JSON.stringify(value)));
-export const yupJsonValidator = yup.string().test("json", "Invalid JSON format", (value) => {
-    if (!value)
-        return true;
-    try {
-        JSON.parse(value);
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-});