@pistonite/pure 0.26.0 → 0.26.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pistonite/pure",
-  "version": "0.26.0",
+  "version": "0.26.2",
   "type": "module",
   "description": "Pure TypeScript libraries for my projects",
   "homepage": "https://github.com/Pistonite/pure",

package/src/pref/locale.ts

@@ -224,14 +224,27 @@ export const setLocale = (newLocale: string): boolean => {
 export const convertToSupportedLocale = (
     newLocale: string,
 ): string | undefined => {
-    if (supportedLocales.includes(newLocale)) {
+    return convertToSupportedLocaleIn(newLocale, supportedLocales);
+};
+
+/**
+ * See {@link convertToSupportedLocale}
+ *
+ * This takes the supported locale array so it can be used
+ * outside of the locale system
+ */
+export const convertToSupportedLocaleIn = (
+    newLocale: string,
+    supportedLocalesToCheck: string[] | readonly string[],
+): string | undefined => {
+    if (supportedLocalesToCheck.includes(newLocale)) {
         return newLocale;
     }
     const language = newLocale.split("-", 2)[0];
-    const len = supportedLocales.length;
+    const len = supportedLocalesToCheck.length;
     for (let i = 0; i < len; i++) {
-        if (supportedLocales[i].startsWith(language)) {
-            return supportedLocales[i];
+        if (supportedLocalesToCheck[i].startsWith(language)) {
+            return supportedLocalesToCheck[i];
         }
     }
     return undefined;

package/src/result/index.ts

@@ -197,19 +197,38 @@ export async function tryAsync<T, E = unknown>(
 }
 
 /** Try best effort converting an error to a string */
-export function errstr(e: unknown): string {
+export function errstr(e: unknown, recursing?: boolean): string {
     if (typeof e === "string") {
         return e;
     }
-    if (e) {
-        if (typeof e === "object" && "message" in e) {
-            if (typeof e.message === "string") {
-                return e.message;
-            }
+    if (!e) {
+        return `${e}`;
+    }
+    if (typeof e === "object" && "message" in e) {
+        if (!recursing) {
+            return errstr(e.message, true);
+        }
+        return `${e.message}`;
+    }
+    if (typeof e === "object" && "toString" in e) {
+        const s = e.toString();
+        if (!recursing) {
+            return errstr(s, true);
         }
-        if (typeof e === "object" && "toString" in e) {
-            return e.toString();
+        return `${s}`;
+    }
+    // try less-likely fields
+    if (typeof e === "object" && "msg" in e) {
+        if (!recursing) {
+            return errstr(e.msg, true);
+        }
+        return `${e.msg}`;
+    }
+    if (typeof e === "object" && "code" in e) {
+        if (!recursing) {
+            return `error code: ${errstr(e.code, true)}`;
         }
+        return `${e.code}`;
     }
     return `${e}`;
 }