@putkoff/abstract-utilities 0.1.172 → 0.1.174

package/dist/cjs/index.js

@@ -53,23 +53,16 @@ function callStorage(method, ...args) {
     }
 }
 /**
- * Safely call localStorage / sessionStorage / any Storage API.
- *
- * @param storageName  "localStorage" or "sessionStorage"
- * @param method       one of the Storage methods, e.g. "getItem", "setItem", etc.
- * @param args         arguments to pass along (e.g. key, value)
- * @returns            whatever the underlying method returns, or undefined if unavailable/fails
+ * Safely call storage methods (`localStorage` or `sessionStorage`) without blowing up.
+ * Returns `undefined` on any error.
  */
 function safeStorage(storageName, method, ...args) {
     try {
-        const storage = globalThis[storageName];
-        if (!storage)
-            return undefined;
-        const fn = storage[method];
-        if (typeof fn !== "function")
+        const store = safeGlobalProp(storageName);
+        if (!store || typeof store[method] !== "function")
             return undefined;
         // @ts-ignore
-        return fn.apply(storage, args);
+        return store[method](...args);
     }
     catch (_a) {
         return undefined;
@@ -77,16 +70,15 @@ function safeStorage(storageName, method, ...args) {
 }
 
 /**
- * Safely walk `window` or `document` to grab nested props without blowing up in Node.
- *
- * @param rootName   "window" or "document"
- * @param path       sequence of property names, e.g. ["location","host"] or ["baseURI"]
+ * Safely walk `globalThis` (or window/document) by a chain of property names.
+ * Returns `undefined` if any step is missing.
  */
-function safeGlobalProp(rootName, ...path) {
-    let obj = globalThis[rootName];
+function safeGlobalProp(...path) {
+    let obj = globalThis;
     for (const key of path) {
-        if (obj == null)
+        if (obj == null || typeof obj !== "object" || !(key in obj)) {
             return undefined;
+        }
         obj = obj[key];
     }
     return obj;
@@ -1143,37 +1135,38 @@ function alertit(obj = null) {
 let _cachedConfig = null;
 function loadConfig() {
     return __awaiter(this, arguments, void 0, function* (filePath = null) {
-        var _a;
-        // 1) decide which path
-        const relativePath = filePath || 'config.json';
-        // 2) pick a base URL: document.baseURI → window.location.href → '/'
-        const base = (_a = getDocumentProp('baseURI')) !== null && _a !== void 0 ? _a : (typeof window !== 'undefined' ? window.location.href : '/');
-        // 3) build the URL, safely
-        let configUrl;
-        try {
-            configUrl = new URL(relativePath, base).href;
-        }
-        catch (err) {
-            console.warn(`[loadConfig] failed to resolve URL for "${relativePath}" against "${base}":`, err);
-            configUrl = relativePath; // try a bare-relative fetch
+        const relativePath = filePath || "config.json";
+        // 1) Resolve URL against document.baseURI if available
+        let configUrl = relativePath;
+        const baseURI = safeGlobalProp("document", "baseURI");
+        if (baseURI) {
+            try {
+                configUrl = new URL(relativePath, baseURI).href;
+            }
+            catch (_a) {
+                // ignore—keep configUrl = relativePath
+            }
         }
-        // 4) return cached if we have it
+        // 2) Return cache if we’ve already fetched once
         if (_cachedConfig) {
             return _cachedConfig;
         }
-        // 5) actually fetch + parse, but never throw
+        // 3) Bail out in non-browser if fetch isn’t present
+        const fetchFn = safeGlobalProp("fetch");
+        if (typeof fetchFn !== "function") {
+            return {};
+        }
+        // 4) Try to fetch + parse, swallowing any errors
         try {
-            const res = yield fetch(configUrl);
-            if (!res.ok) {
-                console.warn(`[loadConfig] server returned ${res.status} when fetching ${configUrl}`);
+            const res = yield fetchFn(configUrl).catch(() => null);
+            if (!res || !res.ok) {
                 return {};
             }
-            const json = (yield res.json());
-            _cachedConfig = json;
-            return json;
+            // parse JSON
+            _cachedConfig = (yield res.json());
+            return _cachedConfig;
         }
-        catch (err) {
-            console.warn(`[loadConfig] error fetching/parsing ${configUrl}:`, err);
+        catch (_b) {
             return {};
         }
     });