@wener/utils 1.1.50 → 1.1.53

package/lib/errors/Errors.test.js

@@ -0,0 +1,24 @@
+import { test } from "vitest";
+import { Errors } from "./Errors.js";
+test("Errors", function () {
+    {
+        var a = "";
+        Errors.NotFound.check(a);
+        var b = a;
+        hole(b);
+    }
+    if (false) {
+        // 不能同时 asserts 且返回
+        // https://stackoverflow.com/a/73252858/1870054
+        // https://github.com/microsoft/TypeScript/issues/34636
+        var a1;
+        Errors.NotFound.require(a1);
+        // let c: string = a;
+        // hole(c);
+    }
+});
+function hole() {
+    for (var _len = arguments.length, _ = new Array(_len), _key = 0; _key < _len; _key++) {
+        _[_key] = arguments[_key];
+    }
+}

package/lib/fetch/HttpStatus.js

@@ -1,6 +1,6 @@
 // http://httpstat.us/
 // https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
-const HttpStatus = {
+var HttpStatus = {
     100: 'Continue',
     101: 'Switching Protocols',
     102: 'Processing',
@@ -90,5 +90,3 @@ export function isRetryableHttpStatus(status) {
             return false;
     }
 }
-
-//# sourceMappingURL=HttpStatus.js.map

package/lib/fetch/createFetchWith.js

@@ -1,23 +1,192 @@
-import { getGlobalThis } from '../runtime/getGlobalThis.js';
-export function createFetchWith({ fetch = getGlobalThis().fetch, onRequest = (ctx)=>ctx.next(ctx.url, ctx.req), onResponse = (ctx)=>ctx.res }) {
-    return async (urlOrRequest, init)=>{
-        const url = String(urlOrRequest);
-        let req = init || {};
-        const nextFetch = req.fetch || fetch;
-        const res = await onRequest({
-            url,
-            req,
-            next: (url, init)=>{
-                req = init;
-                return nextFetch(url, init);
+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);
             }
-        }) ?? await nextFetch(url, init);
-        return onResponse({
-            url,
-            req,
-            res
+            _next(undefined);
         });
     };
 }
-
-//# sourceMappingURL=createFetchWith.js.map
+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 { getGlobalThis } from "../web/getGlobalThis.js";
+export function createFetchWith(param) {
+    var _param_fetch = param.fetch, fetch = _param_fetch === void 0 ? getGlobalThis().fetch : _param_fetch, _param_onRequest = param.onRequest, onRequest = _param_onRequest === void 0 ? function (ctx) {
+        return ctx.next(ctx.url, ctx.req);
+    } : _param_onRequest, _param_onResponse = param.onResponse, onResponse = _param_onResponse === void 0 ? function (ctx) {
+        return ctx.res;
+    } : _param_onResponse;
+    return function (urlOrRequest, init) {
+        return _async_to_generator(function () {
+            var url, req, nextFetch, _ref, res, _tmp;
+            return _ts_generator(this, function (_state) {
+                switch (_state.label) {
+                    case 0:
+                        url = String(urlOrRequest);
+                        req = init || {};
+                        nextFetch = req.fetch || fetch;
+                        return [
+                            4,
+                            onRequest({
+                                url: url,
+                                req: req,
+                                next: function (url, init) {
+                                    req = init;
+                                    return nextFetch(url, init);
+                                }
+                            })
+                        ];
+                    case 1:
+                        if (!((_ref = _state.sent()) !== null && _ref !== void 0))
+                            return [
+                                3,
+                                2
+                            ];
+                        _tmp = _ref;
+                        return [
+                            3,
+                            4
+                        ];
+                    case 2:
+                        return [
+                            4,
+                            nextFetch(url, init)
+                        ];
+                    case 3:
+                        _tmp = _state.sent();
+                        _state.label = 4;
+                    case 4:
+                        res = _tmp;
+                        return [
+                            2,
+                            onResponse({
+                                url: url,
+                                req: req,
+                                res: res
+                            })
+                        ];
+                }
+            });
+        })();
+    };
+}

package/lib/fetch/createFetchWithLogging.js

@@ -1,25 +1,26 @@
-import { createFetchWith } from './createFetchWith.js';
-import { dumpRequest } from './dumpRequest.js';
-import { dumpResponse } from './dumpResponse.js';
-export function createFetchWithLogging({ fetch, log = console.log } = {}) {
+import { createFetchWith } from "./createFetchWith.js";
+import { dumpRequest } from "./dumpRequest.js";
+import { dumpResponse } from "./dumpResponse.js";
+export function createFetchWithLogging() {
+    var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, fetch = _ref.fetch, _ref_log = _ref.log, log = _ref_log === void 0 ? console.log : _ref_log;
     return createFetchWith({
-        fetch,
-        onRequest: ({ url, req })=>{
+        fetch: fetch,
+        onRequest: function (param) {
+            var url = param.url, req = param.req;
             void dumpRequest({
-                url,
-                req,
-                log
+                url: url,
+                req: req,
+                log: log
             });
         },
-        onResponse: ({ url, req, res })=>{
+        onResponse: function (param) {
+            var url = param.url, req = param.req, res = param.res;
             return dumpResponse({
-                url,
-                req,
-                res,
-                log
+                url: url,
+                req: req,
+                res: res,
+                log: log
             });
         }
     });
 }
-
-//# sourceMappingURL=createFetchWithLogging.js.map

package/lib/fetch/createFetchWithRetry.js

@@ -1,60 +1,78 @@
-import { getGlobalThis } from '../runtime/getGlobalThis.js';
-export function createFetchWithRetry({ fetch = getGlobalThis().fetch, retries = 3, retryDelay = 1000, retryOn = [] } = {}) {
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    }
+    else {
+        return left instanceof right;
+    }
+}
+import { getGlobalThis } from "../web/getGlobalThis.js";
+export function createFetchWithRetry() {
+    var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref_fetch = _ref.fetch, fetch = _ref_fetch === void 0 ? getGlobalThis().fetch : _ref_fetch, _ref_retries = _ref.retries, retries = _ref_retries === void 0 ? 3 : _ref_retries, _ref_retryDelay = _ref.retryDelay, retryDelay = _ref_retryDelay === void 0 ? 1000 : _ref_retryDelay, _ref_retryOn = _ref.retryOn, retryOn = _ref_retryOn === void 0 ? [] : _ref_retryOn;
     // https://github.com/jonbern/fetch-retry/blob/master/index.js
     return function fetchRetry(input, init) {
-        return new Promise(function(resolve, reject) {
-            var wrappedFetch = function(attempt) {
+        return new Promise(function (resolve, reject) {
+            var wrappedFetch = function wrappedFetch(attempt) {
                 // As of node 18, this is no longer needed since node comes with native support for fetch:
-                /* istanbul ignore next */ var _input = typeof Request !== 'undefined' && input instanceof Request ? input.clone() : input;
-                fetch(_input, init).then(function(response) {
+                /* istanbul ignore next */ var _input = typeof Request !== "undefined" && _instanceof(input, Request) ? input.clone() : input;
+                fetch(_input, init).then(function (response) {
                     if (Array.isArray(retryOn) && retryOn.indexOf(response.status) === -1) {
                         resolve(response);
-                    } else if (typeof retryOn === 'function') {
+                    }
+                    else if (typeof retryOn === "function") {
                         try {
-                            return Promise.resolve(retryOn(attempt, null, response)).then(function(retryOnResponse) {
+                            return Promise.resolve(retryOn(attempt, null, response)).then(function (retryOnResponse) {
                                 if (retryOnResponse) {
                                     retry(attempt, null, response);
-                                } else {
+                                }
+                                else {
                                     resolve(response);
                                 }
                             }).catch(reject);
-                        } catch (error) {
+                        }
+                        catch (error) {
                             reject(error);
                         }
-                    } else {
+                    }
+                    else {
                         if (attempt < retries) {
                             retry(attempt, null, response);
-                        } else {
+                        }
+                        else {
                             resolve(response);
                         }
                     }
                     return;
-                }).catch(function(error) {
-                    if (typeof retryOn === 'function') {
+                }).catch(function (error) {
+                    if (typeof retryOn === "function") {
                         try {
                             // eslint-disable-next-line no-undef
-                            Promise.resolve(retryOn(attempt, error, null)).then(function(retryOnResponse) {
+                            Promise.resolve(retryOn(attempt, error, null)).then(function (retryOnResponse) {
                                 if (retryOnResponse) {
                                     retry(attempt, error, null);
-                                } else {
+                                }
+                                else {
                                     reject(error);
                                 }
-                            }).catch(function(error) {
+                            }).catch(function (error) {
                                 reject(error);
                             });
-                        } catch (error) {
+                        }
+                        catch (error) {
                             reject(error);
                         }
-                    } else if (attempt < retries) {
+                    }
+                    else if (attempt < retries) {
                         retry(attempt, error, null);
-                    } else {
+                    }
+                    else {
                         reject(error);
                     }
                 });
             };
             function retry(attempt, error, response) {
-                let delay = typeof retryDelay === 'function' ? retryDelay(attempt, error, response) : retryDelay;
-                setTimeout(function() {
+                var delay = typeof retryDelay === "function" ? retryDelay(attempt, error, response) : retryDelay;
+                setTimeout(function () {
                     wrappedFetch(++attempt);
                 }, delay);
             }
@@ -62,5 +80,3 @@ export function createFetchWithRetry({ fetch = getGlobalThis().fetch, retries =
         });
     };
 }
-
-//# sourceMappingURL=createFetchWithRetry.js.map