@lightsparkdev/core 1.3.1 → 1.4.0

package/src/utils/errors.ts

@@ -1,3 +1,4 @@
+import { isObject } from "./typeGuards.js";
 import { type JSONType } from "./types.js";
 
 export const isError = (e: unknown): e is Error => {
@@ -35,15 +36,35 @@ export const isErrorMsg = (e: unknown, msg: string) => {
   return false;
 };
 
-export function errorToJSON(err: unknown) {
+/* Make non-enumerable properties like message and stack enumerable so they
+   can be handled by JSON.stringify */
+function normalizeObject(obj: unknown): Record<string, unknown> {
+  const normalized: Record<string, unknown> = {};
+  if (isObject(obj)) {
+    const props = Object.getOwnPropertyNames(obj);
+    for (const prop of props) {
+      const objRecord = obj as Record<string, unknown>;
+      normalized[prop] = objRecord[prop];
+    }
+  }
+  return normalized;
+}
+
+export function errorToJSON(
+  err: unknown,
+  /* Enable stringifying non-primitives globally for subpaths.
+     Useful for enforcing single level error objects: */
+  stringifyObjects = false,
+) {
   if (!err) {
     return null;
   }
-  if (
-    typeof err === "object" &&
-    "toJSON" in err &&
-    typeof err.toJSON === "function"
-  ) {
+
+  /* Objects can add standard toJSON method to determine JSON.stringify output, https://mzl.la/3Gks9zu: */
+  if (isObject(err) && "toJSON" in err && typeof err.toJSON === "function") {
+    if (stringifyObjects === true) {
+      return objectToJSON(err.toJSON());
+    }
     return err.toJSON() as JSONType;
   }
 
@@ -57,7 +78,28 @@ export function errorToJSON(err: unknown) {
     return { message: err.message };
   }
 
+  return objectToJSON(err);
+}
+
+function objectToJSON(obj: unknown) {
+  const normalizedObj = normalizeObject(obj);
   return JSON.parse(
-    JSON.stringify(err, Object.getOwnPropertyNames(err)),
+    JSON.stringify(normalizedObj, (key, value: unknown) => {
+      /* Initial call passes the top level object with empty key: */
+      if (key === "") {
+        return value;
+      }
+
+      const objProps = Object.getOwnPropertyNames(normalizedObj);
+      if (!objProps.includes(key)) {
+        return undefined;
+      }
+
+      if (isObject(value)) {
+        return JSON.stringify(value);
+      }
+
+      return value;
+    }),
   ) as JSONType;
 }

package/src/utils/localStorage.ts

@@ -1,15 +1,31 @@
 import { type ConfigKeys } from "../constants/index.js";
 
 export function getLocalStorageConfigItem(key: ConfigKeys) {
-  return getLocalStorageBoolean(key);
+  const localStorageBoolean = getLocalStorageBoolean(key);
+  // If config not set, just default to false
+  if (localStorageBoolean == null) {
+    return false;
+  }
+
+  return localStorageBoolean;
 }
 
 export function getLocalStorageBoolean(key: string) {
   /* localStorage is not available in all contexts, use try/catch: */
   try {
-    return localStorage.getItem(key) === "1";
+    if (localStorage.getItem(key) === "1") {
+      return true;
+    }
+    // Key is not set
+    else if (localStorage.getItem(key) == null) {
+      return null;
+    }
+    // Key is set but not "1"
+    else {
+      return false;
+    }
   } catch (e) {
-    return false;
+    return null;
   }
 }
 

package/src/utils/typeGuards.ts

@@ -2,7 +2,16 @@ export function isUint8Array(value: unknown): value is Uint8Array {
   return value instanceof Uint8Array;
 }
 
-export function isObject(value: unknown): value is Record<string, unknown> {
+export function isObject(value: unknown): value is object {
   const type = typeof value;
   return value != null && (type == "object" || type == "function");
 }
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    Object.prototype.toString.call(value) === "[object Object]"
+  );
+}

package/src/utils/types.ts

@@ -59,7 +59,3 @@ export type Complete<T> = { [P in keyof T]-?: NonNullable<T[P]> };
 export type RequiredKeys<T> = {
   [K in keyof T]-?: Record<string, never> extends Pick<T, K> ? never : K;
 }[keyof T];
-
-export function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}