@wener/utils 1.1.51 → 1.1.53

package/lib/fetch/dumpResponse.test.js

@@ -0,0 +1,393 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    }
+    catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    }
+    else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function () {
+        var self = this, args = arguments;
+        return new Promise(function (resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function () {
+            if (t[0] & 1)
+                throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+        return this;
+    }), g;
+    function verb(n) {
+        return function (v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f)
+            throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _)
+            try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                    return t;
+                if (y = 0, t)
+                    op = [
+                        op[0] & 2,
+                        t.value
+                    ];
+                switch (op[0]) {
+                    case 0:
+                    case 1:
+                        t = op;
+                        break;
+                    case 4:
+                        _.label++;
+                        return {
+                            value: op[1],
+                            done: false
+                        };
+                    case 5:
+                        _.label++;
+                        y = op[1];
+                        op = [
+                            0
+                        ];
+                        continue;
+                    case 7:
+                        op = _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                            _ = 0;
+                            continue;
+                        }
+                        if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                            _.label = op[1];
+                            break;
+                        }
+                        if (op[0] === 6 && _.label < t[1]) {
+                            _.label = t[1];
+                            t = op;
+                            break;
+                        }
+                        if (t && _.label < t[2]) {
+                            _.label = t[2];
+                            _.ops.push(op);
+                            break;
+                        }
+                        if (t[2])
+                            _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) {
+                op = [
+                    6,
+                    e
+                ];
+                y = 0;
+            }
+            finally {
+                f = t = 0;
+            }
+        if (op[0] & 5)
+            throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { describe, expect, it, vi } from "vitest";
+import { dumpResponse } from "./dumpResponse.js";
+describe("dumpResponse", function () {
+    var NETWORK_TIMEOUT = 15000;
+    it("should dump JSON response with all parameters", function () {
+        return _async_to_generator(function () {
+            var logSpy, response, result, loggedOutput;
+            return _ts_generator(this, function (_state) {
+                switch (_state.label) {
+                    case 0:
+                        logSpy = vi.fn();
+                        return [
+                            4,
+                            fetch("https://httpbin.org/json")
+                        ];
+                    case 1:
+                        response = _state.sent();
+                        return [
+                            4,
+                            dumpResponse({
+                                res: response,
+                                url: "https://httpbin.org/json",
+                                method: "GET",
+                                log: logSpy,
+                                dumpBody: true
+                            })
+                        ];
+                    case 2:
+                        result = _state.sent();
+                        expect(logSpy).toHaveBeenCalledOnce();
+                        loggedOutput = logSpy.mock.calls[0][0];
+                        // Check basic format
+                        expect(loggedOutput).toContain("<- 200 OK GET https://httpbin.org/json");
+                        expect(loggedOutput).toContain("content-type: application/json");
+                        expect(loggedOutput).toContain("slideshow");
+                        // Should return original response
+                        expect(result).toBe(response);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    }, NETWORK_TIMEOUT);
+    it("should work with minimal parameters", function () {
+        return _async_to_generator(function () {
+            var logSpy, response, loggedOutput;
+            return _ts_generator(this, function (_state) {
+                switch (_state.label) {
+                    case 0:
+                        logSpy = vi.fn();
+                        return [
+                            4,
+                            fetch("https://httpbin.org/status/204")
+                        ];
+                    case 1:
+                        response = _state.sent();
+                        return [
+                            4,
+                            dumpResponse({
+                                res: response,
+                                log: logSpy
+                            })
+                        ];
+                    case 2:
+                        _state.sent();
+                        loggedOutput = logSpy.mock.calls[0][0];
+                        // Should only show status without method/url (HTTPBin uses uppercase)
+                        expect(loggedOutput).toContain("<- 204");
+                        expect(loggedOutput).not.toContain("GET");
+                        expect(loggedOutput).not.toContain("https://");
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    }, NETWORK_TIMEOUT);
+    it("should handle binary content", function () {
+        return _async_to_generator(function () {
+            var logSpy, response, loggedOutput;
+            return _ts_generator(this, function (_state) {
+                switch (_state.label) {
+                    case 0:
+                        logSpy = vi.fn();
+                        // Create a mock response with binary content
+                        response = new Response(new Uint8Array([
+                            1,
+                            2,
+                            3
+                        ]), {
+                            status: 200,
+                            statusText: "OK",
+                            headers: {
+                                "content-type": "application/octet-stream"
+                            }
+                        });
+                        return [
+                            4,
+                            dumpResponse({
+                                res: response,
+                                url: "https://example.com/binary",
+                                method: "GET",
+                                log: logSpy
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        loggedOutput = logSpy.mock.calls[0][0];
+                        expect(loggedOutput).toContain("<- 200 OK GET https://example.com/binary");
+                        expect(loggedOutput).toContain("[Binary content not displayed: application/octet-stream]");
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it("should preserve original response after dumping", function () {
+        return _async_to_generator(function () {
+            var response, result, data;
+            return _ts_generator(this, function (_state) {
+                switch (_state.label) {
+                    case 0:
+                        return [
+                            4,
+                            fetch("https://httpbin.org/json")
+                        ];
+                    case 1:
+                        response = _state.sent();
+                        return [
+                            4,
+                            dumpResponse({
+                                res: response,
+                                dumpBody: true
+                            })
+                        ];
+                    case 2:
+                        result = _state.sent();
+                        return [
+                            4,
+                            result.json()
+                        ];
+                    case 3:
+                        data = _state.sent();
+                        expect(data.slideshow).toBeDefined();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    }, NETWORK_TIMEOUT);
+    it("should handle dumpBody false with mock response", function () {
+        return _async_to_generator(function () {
+            var logSpy, response, loggedOutput;
+            return _ts_generator(this, function (_state) {
+                switch (_state.label) {
+                    case 0:
+                        logSpy = vi.fn();
+                        response = new Response("{\"test\": true}", {
+                            status: 200,
+                            statusText: "OK",
+                            headers: {
+                                "content-type": "application/json"
+                            }
+                        });
+                        return [
+                            4,
+                            dumpResponse({
+                                res: response,
+                                url: "https://example.com/test",
+                                method: "POST",
+                                log: logSpy,
+                                dumpBody: false
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        loggedOutput = logSpy.mock.calls[0][0];
+                        // Should not contain body content
+                        expect(loggedOutput).toContain("<- 200 OK POST https://example.com/test");
+                        expect(loggedOutput).toContain("content-type: application/json");
+                        expect(loggedOutput).not.toContain("{\"test\": true}");
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it("should handle req.method fallback", function () {
+        return _async_to_generator(function () {
+            var logSpy, response, loggedOutput;
+            return _ts_generator(this, function (_state) {
+                switch (_state.label) {
+                    case 0:
+                        logSpy = vi.fn();
+                        response = new Response("success", {
+                            status: 200,
+                            statusText: "OK",
+                            headers: {
+                                "content-type": "text/plain"
+                            }
+                        });
+                        return [
+                            4,
+                            dumpResponse({
+                                res: response,
+                                req: {
+                                    method: "PUT"
+                                },
+                                url: "https://example.com/test",
+                                log: logSpy
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        loggedOutput = logSpy.mock.calls[0][0];
+                        expect(loggedOutput).toContain("<- 200 OK PUT https://example.com/test");
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it("should handle method parameter override", function () {
+        return _async_to_generator(function () {
+            var logSpy, response, loggedOutput;
+            return _ts_generator(this, function (_state) {
+                switch (_state.label) {
+                    case 0:
+                        logSpy = vi.fn();
+                        response = new Response("success", {
+                            status: 201,
+                            statusText: "Created"
+                        });
+                        return [
+                            4,
+                            dumpResponse({
+                                res: response,
+                                req: {
+                                    method: "POST"
+                                },
+                                method: "PATCH",
+                                url: "https://example.com/test",
+                                log: logSpy
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        loggedOutput = logSpy.mock.calls[0][0];
+                        expect(loggedOutput).toContain("<- 201 Created PATCH https://example.com/test");
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+});

package/lib/fetch/http.types.js

@@ -1,4 +1,2 @@
 // from hono
 export { };
-
-//# sourceMappingURL=http.types.js.map

package/lib/fetch/index.js

@@ -1,7 +1,5 @@
-export { createFetchWith } from './createFetchWith.js';
-export { createFetchWithLogging } from './createFetchWithLogging.js';
-export { dumpRequest } from './dumpRequest.js';
-export { dumpResponse } from './dumpResponse.js';
-export { createFetchWithRetry } from './createFetchWithRetry.js';
-
-//# sourceMappingURL=index.js.map
+export { createFetchWith } from "./createFetchWith.js";
+export { createFetchWithLogging } from "./createFetchWithLogging.js";
+export { dumpRequest } from "./dumpRequest.js";
+export { dumpResponse } from "./dumpResponse.js";
+export { createFetchWithRetry } from "./createFetchWithRetry.js";

package/lib/fetch/isTextContentType.js

@@ -0,0 +1,5 @@
+/**
+ * Check if the content type represents text content that can be safely displayed
+ */ export function isTextContentType(contentType) {
+    return contentType.includes('application/json') || contentType.includes('text/') || contentType.includes('application/xml') || contentType.includes('application/javascript') || contentType.includes('application/x-www-form-urlencoded');
+}

package/lib/fetch/resolveRequest.js

@@ -0,0 +1,7 @@
+function _object_destructuring_empty(o) {
+    if (o === null || o === void 0) throw new TypeError("Cannot destructure " + o);
+    return o;
+}
+export function resolveRequest(param) {
+    var ref = _object_destructuring_empty(param);
+}

package/lib/fetch/types.js

@@ -1,3 +1 @@
 export { };
-
-//# sourceMappingURL=types.js.map

package/lib/i18n/createTranslate.js

@@ -1,14 +1,14 @@
-import { get } from '../objects/get.js';
-import { renderTemplate } from '../strings/renderTemplate.js';
+import { get } from "../objects/get.js";
+import { renderTemplate } from "../strings/renderTemplate.js";
 export function createTranslate(obj) {
-    let locale = '';
-    const tree = obj || {};
+    var locale = "";
+    var tree = obj || {};
     // en-US -> en-US,en
-    const keyOfDict = (s)=>{
+    var keyOfDict = function (s) {
         if (Array.isArray(s)) {
             return s;
         }
-        const sp = s.split(/[_-]/);
+        var sp = s.split(/[_-]/);
         if (sp.length > 1) {
             return [
                 s,
@@ -20,35 +20,55 @@ export function createTranslate(obj) {
         ];
     };
     return {
-        locale (lang) {
+        locale: function locale1(lang) {
             return locale = lang || locale;
         },
-        dict: (lang, dict)=>{
+        dict: function (lang, dict) {
             if (dict) {
                 tree[lang] = Object.assign(tree[lang] || {}, dict);
                 return;
             }
             return tree[lang];
         },
-        t (key, params, lang) {
-            let val;
-            for (const k of keyOfDict(lang || locale)){
-                val = get(tree[k], key, '');
-                if (val) {
-                    break;
+        t: function t(key, params, lang) {
+            var val;
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for (var _iterator = keyOfDict(lang || locale)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                    var k = _step.value;
+                    val = get(tree[k], key, "");
+                    if (val) {
+                        break;
+                    }
                 }
             }
-            if (process.env.NODE_ENV === 'development') {
+            catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            }
+            finally {
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                }
+                finally {
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            if (process.env.NODE_ENV === "development") {
                 if (val == null) {
-                    console.error(`[Translate] Missing the "${[].concat(key).join('.')}" key within the "${lang || locale}" dictionary`);
+                    console.error("[Translate] Missing the \"".concat([].concat(key).join("."), "\" key within the \"").concat(lang || locale, "\" dictionary"));
                     return;
                 }
             }
-            if (typeof val === 'function') return val(params);
-            if (typeof val === 'string') return renderTemplate(val, params, 'common');
+            if (typeof val === "function")
+                return val(params);
+            if (typeof val === "string")
+                return renderTemplate(val, params, "common");
             return val;
         }
     };
 }
-
-//# sourceMappingURL=createTranslate.js.map