@grest-ts/common 0.0.5

package/src/UnreachableCode.ts

@@ -0,0 +1,9 @@
+export class UnreachableCode {
+    public static never<T>(input: never, defaultValue?: T): T {
+        return defaultValue;
+    }
+
+    public static throwNever<T>(input: never, defaultValue?: Error): T {
+        throw defaultValue;
+    }
+}

package/src/deepClone.ts

@@ -0,0 +1,43 @@
+/**
+ * Recursively clones an object and all its nested properties.
+ * Handles: primitives, arrays, plain objects, Date, Map, Set.
+ */
+export function deepClone<T>(obj: T): T {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+
+    if (typeof obj !== 'object') {
+        return obj;
+    }
+
+    if (obj instanceof Date) {
+        return new Date(obj.getTime()) as T;
+    }
+
+    if (obj instanceof Map) {
+        const clonedMap = new Map();
+        for (const [key, value] of obj) {
+            clonedMap.set(deepClone(key), deepClone(value));
+        }
+        return clonedMap as T;
+    }
+
+    if (obj instanceof Set) {
+        const clonedSet = new Set();
+        for (const value of obj) {
+            clonedSet.add(deepClone(value));
+        }
+        return clonedSet as T;
+    }
+
+    if (Array.isArray(obj)) {
+        return obj.map(item => deepClone(item)) as T;
+    }
+
+    const clonedObj: Record<string, unknown> = {};
+    for (const key of Object.keys(obj)) {
+        clonedObj[key] = deepClone((obj as Record<string, unknown>)[key]);
+    }
+    return clonedObj as T;
+}

package/src/deepFreeze.ts

@@ -0,0 +1,21 @@
+/**
+ * Recursively freezes an object and all its nested properties.
+ * Used to create immutable objects.
+ */
+export function deepFreeze<T>(o: T): T {
+    if (o === undefined) {
+        return o;
+    }
+    Object.freeze(o);
+    Object.getOwnPropertyNames(o).forEach(function (prop) {
+        if (prop === "renderers") {
+            return;
+        }
+        if ((o as any)[prop] !== null
+            && (typeof (o as any)[prop] === "object" || typeof (o as any)[prop] === "function")
+            && !Object.isFrozen((o as any)[prop])) {
+            deepFreeze((o as any)[prop]);
+        }
+    });
+    return o;
+}

package/src/environment.ts

@@ -0,0 +1,22 @@
+/**
+ * Environment detection utilities that work without DOM lib
+ * Uses type assertions to avoid TypeScript errors in Node-only contexts
+ */
+
+// Declare window type to avoid TS errors when DOM lib is not included
+declare const window: { document?: unknown } | undefined
+
+/**
+ * Check if code is running in a browser environment
+ * Works in both Node.js and browser contexts without requiring DOM lib
+ */
+export function isBrowser(): boolean {
+    return typeof window !== 'undefined' && typeof window.document !== 'undefined'
+}
+
+/**
+ * Check if code is running in a Node.js environment
+ */
+export function isNode(): boolean {
+    return !isBrowser()
+}

package/src/http.ts

@@ -0,0 +1,52 @@
+export enum HttpStatusCode {
+    OK200 = 200,
+    /**
+     * Completely fails to handle the request
+     */
+    BadRequest400 = 400,
+    /**
+     * User must send auth headers or in other ways be "logged in".
+     */
+    Unauthorized401 = 401,
+    /**
+     * User does not have access to resource
+     */
+    Forbidden403 = 403,
+    /**
+     * Entity not found
+     */
+    NotFound404 = 404,
+    /**
+     * Duplicate entity somewhere
+     */
+    Exists409 = 409,
+    /**
+     * These are validation errors - automatic or manual.
+     */
+    ValidationError422 = 422,
+    /**
+     * Method not allowed on this resource.
+     */
+    MethodNotAllowed405 = 405,
+    /**
+     * Generic "something went wrong".
+     */
+    InternalServerError500 = 500,
+    /**
+     * Bad Gateway - proxy/gateway received invalid response.
+     */
+    BadGateway502 = 502,
+    /**
+     * Server is shutting down and is not able to handle the request.
+     */
+    ServerTemporarilyNotAvailable503 = 503,
+
+
+    /**
+     * Non standard HTTP error! This is used in the test framework in case request failes because of some testing check.
+     * Request itself maybe succeeded, but some check caused it to still fail. This never comes up in production, only in automated tests.
+     */
+    TestingError = 800
+}
+
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS";

package/src/index-browser.ts

@@ -0,0 +1,12 @@
+export * from './deepFreeze';
+export * from './deepClone';
+export * from './withTimeout';
+export * from './GGError';
+export * from './UnreachableCode';
+export * from './types';
+export * from './http';
+export * from './Secret';
+export * from "./sleep"
+export * from "./environment"
+export * from "./GGAsyncStorage"
+// GGExtensionDiscovery excluded — uses Node.js fs/path/url

package/src/index-node.ts

@@ -0,0 +1,12 @@
+export * from './deepFreeze';
+export * from './deepClone';
+export * from './withTimeout';
+export * from './GGError';
+export * from './UnreachableCode';
+export * from './types';
+export * from './http';
+export * from './Secret';
+export * from "./sleep"
+export * from "./environment"
+export * from "./GGAsyncStorage"
+export * from "./GGExtensionDiscovery"

package/src/sleep.ts

@@ -0,0 +1,3 @@
+export function sleep(ms: number, _reason?: string): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/src/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "//": "THIS FILE IS GENERATED - DO NOT EDIT",
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "lib": [
+      "ES2022",
+      "DOM"
+    ],
+    "types": [
+      "node"
+    ]
+  },
+  "include": [
+    "**/*"
+  ]
+}

package/src/types.ts

@@ -0,0 +1,16 @@
+/**
+ * Recursively makes all properties of an object optional.
+ * Useful for partial matching in tests and validation.
+ */
+export type DeepPartial<T> = T extends object
+    ? T extends Array<infer U>
+        ? Array<DeepPartial<U>>
+        : { [P in keyof T]?: DeepPartial<T[P]> }
+    : T
+
+export type ConstructorOf<T> = new (...args: any[]) => T;
+
+/**
+ * Returns the instance of a class. T would be the class reference.
+ */
+export type InstanceOf<T> = T extends { new(...args: any[]): infer S } ? S : undefined

package/src/withTimeout.ts

@@ -0,0 +1,20 @@
+/**
+ * Wraps a promise with a timeout. If the promise doesn't resolve/reject within
+ * the specified timeout, the returned promise will reject with an error.
+ *
+ * @param promise - The promise to wrap
+ * @param timeoutMs - Timeout in milliseconds
+ * @param errorMessage - Error message to use when timeout occurs
+ * @returns A promise that resolves/rejects with the original promise or times out
+ */
+export async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, errorMessage: string): Promise<T> {
+    let timeoutId: any;
+    const timeoutPromise = new Promise<never>((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error(errorMessage)), timeoutMs);
+    });
+    try {
+        return await Promise.race([promise, timeoutPromise]);
+    } finally {
+        clearTimeout(timeoutId!);
+    }
+}