@wener/utils 1.1.51 → 1.1.54

package/lib/errors/DetailError.js

@@ -0,0 +1,297 @@
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) {
+        _construct = Reflect.construct;
+    }
+    else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class)
+                _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor)
+            descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps)
+        _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps)
+        _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    }
+    else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass)
+        _set_prototype_of(subClass, superClass);
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _object_spread(target) {
+    for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function (key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function wrapNativeSuper(Class) {
+        if (Class === null || !_is_native_function(Class))
+            return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class))
+                return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () { }));
+    }
+    catch (_) { }
+    return (_is_native_reflect_construct = function () {
+        return !!result;
+    })();
+}
+import { getHttpStatusText } from "../fetch/HttpStatus.js";
+export var DetailError = /*#__PURE__*/ function (Error1) {
+    "use strict";
+    _inherits(DetailError, Error1);
+    function DetailError(detail) {
+        _class_call_check(this, DetailError);
+        var _this;
+        _this = _call_super(this, DetailError, [
+            detail.message,
+            {
+                cause: detail.cause
+            }
+        ]), _define_property(_this, "detail", void 0), _define_property(_this, "status", void 0), _define_property(_this, "description", void 0);
+        _this.detail = detail;
+        _this.status = detail.status;
+        _this.description = detail.description;
+        return _this;
+    }
+    _create_class(DetailError, [
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                return {
+                    code: this.detail.code,
+                    message: this.message,
+                    status: this.status,
+                    description: this.description,
+                    cause: this.cause
+                };
+            }
+        }
+    ]);
+    return DetailError;
+}(_wrap_native_super(Error));
+export var DetailHolder = /*#__PURE__*/ function () {
+    "use strict";
+    function DetailHolder(param) {
+        var status = param.status, _param_message = param.message, message = _param_message === void 0 ? getHttpStatusText(status) : _param_message, _param_code = param.code, code = _param_code === void 0 ? status : _param_code, metadata = param.metadata, description = param.description, cause = param.cause;
+        _class_call_check(this, DetailHolder);
+        _define_property(this, "message", void 0);
+        _define_property(this, "status", void 0);
+        _define_property(this, "code", void 0);
+        _define_property(this, "metadata", void 0);
+        _define_property(this, "description", void 0);
+        _define_property(this, "cause", void 0);
+        this.message = message !== null && message !== void 0 ? message : String(status);
+        this.status = status;
+        this.code = code;
+        this.description = description;
+        this.metadata = metadata;
+        this.cause = cause;
+    }
+    _create_class(DetailHolder, [
+        {
+            key: "with",
+            value: function _with(o) {
+                if (typeof o === "string") {
+                    o = {
+                        message: o
+                    };
+                }
+                if (o === undefined) {
+                    return new DetailHolder(this);
+                }
+                return new DetailHolder(_object_spread({
+                    status: this.status,
+                    code: this.code,
+                    message: this.message,
+                    metadata: this.metadata,
+                    cause: this.cause
+                }, o));
+            }
+        },
+        {
+            key: "asError",
+            value: function asError(o) {
+                if (typeof o === "string") {
+                    o = {
+                        message: o
+                    };
+                }
+                return new DetailError(this.with(o));
+            }
+        },
+        {
+            key: "require",
+            value: function require(v, o) {
+                if (v === undefined || v === null) {
+                    throw this.asError(o);
+                }
+                return v;
+            }
+        },
+        {
+            key: "check",
+            value: function check(cond, o) {
+                switch (cond) {
+                    case false:
+                    case undefined:
+                    case null:
+                        {
+                            throw this.asError(o);
+                        }
+                }
+            }
+        },
+        {
+            key: "throw",
+            value: function _throw(o) {
+                throw this.asError(o);
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                return {
+                    code: this.code,
+                    message: this.message,
+                    status: this.status,
+                    description: this.description,
+                    cause: this.cause,
+                    metadata: this.metadata
+                };
+            }
+        },
+        {
+            key: "asResponse",
+            value: function asResponse() {
+                return new Response(JSON.stringify(this.toJSON()), {
+                    status: this.status,
+                    statusText: this.description,
+                    headers: {
+                        "Content-Type": "application/json"
+                    }
+                });
+            }
+        }
+    ]);
+    return DetailHolder;
+}();

package/lib/errors/Errors.js

@@ -1,115 +1,68 @@
-import { getHttpStatusText } from '../fetch/HttpStatus.js';
-export class DetailError extends Error {
-    detail;
-    status;
-    description;
-    constructor(detail){
-        super(detail.message, {
-            cause: detail.cause
-        }), this.detail = detail;
-        this.status = detail.status;
-        this.description = detail.description;
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
     }
-    toJSON() {
-        return {
-            code: this.detail.code,
-            message: this.message,
-            status: this.status,
-            description: this.description,
-            cause: this.cause
-        };
+    else {
+        obj[key] = value;
     }
+    return obj;
 }
-let DetailHolder = class DetailHolder {
-    message;
-    status;
-    code;
-    metadata;
-    description;
-    cause;
-    constructor({ status, message = getHttpStatusText(status), code = status, metadata, description, cause }){
-        this.message = message ?? String(status);
-        this.status = status;
-        this.code = code;
-        this.description = description;
-        this.metadata = metadata;
-        this.cause = cause;
-    }
-    with(o) {
-        if (typeof o === 'string') {
-            o = {
-                message: o
-            };
-        }
-        if (o === undefined) {
-            return new DetailHolder(this);
-        }
-        return new DetailHolder({
-            status: this.status,
-            code: this.code,
-            message: this.message,
-            metadata: this.metadata,
-            cause: this.cause,
-            ...o
-        });
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
     }
-    asError(o) {
-        if (typeof o === 'string') {
-            o = {
-                message: o
-            };
-        }
-        return new DetailError(this.with(o));
+    else {
+        return left instanceof right;
     }
-    require(v, o) {
-        if (v === undefined || v === null) {
-            throw this.asError(o);
+}
+function _object_spread(target) {
+    for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
         }
-        return v;
+        ownKeys.forEach(function (key) {
+            _define_property(target, key, source[key]);
+        });
     }
-    check(cond, o) {
-        switch(cond){
-            case false:
-            case undefined:
-            case null:
-                {
-                    throw this.asError(o);
-                }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function (sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
         }
+        keys.push.apply(keys, symbols);
     }
-    throw(o) {
-        throw this.asError(o);
-    }
-    toJSON() {
-        return {
-            code: this.code,
-            message: this.message,
-            status: this.status,
-            description: this.description,
-            cause: this.cause,
-            metadata: this.metadata
-        };
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
     }
-    asResponse() {
-        return new Response(JSON.stringify(this.toJSON()), {
-            status: this.status,
-            statusText: this.description,
-            headers: {
-                'Content-Type': 'application/json'
-            }
+    else {
+        ownKeys(Object(source)).forEach(function (key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
         });
     }
-};
-export var Errors;
-(function(Errors) {
-    /*
-https://github.com/tc39/proposal-error-cause
-https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause
-Stage 3
-Chrome 93, Safari 15, Node 16.9
-
-https://www.npmjs.com/package/pony-cause
-   */ Errors.BadRequest = create({
+    return target;
+}
+import { DetailError, DetailHolder } from "./DetailError.js";
+(function (Errors) {
+    Errors.BadRequest = create({
         status: 400
     });
     Errors.Unauthorized = create({
@@ -127,20 +80,29 @@ https://www.npmjs.com/package/pony-cause
     Errors.NotImplemented = create({
         status: 501
     });
+    Errors.BadGateway = create({
+        status: 502,
+        message: "Bad Gateway"
+    });
     Errors.ServiceUnavailable = create({
         status: 503
     });
-    // known errors
-    // TypeError  when an operation could not be performed, typically (but not exclusively) when a value is not of the expected type.
-    // RangeError  when a number is not within the correct range allowed.
-    // AggregateError  when multiple errors need to be reported by an operation, for example by Promise.all().
-    //  例如 Promise.any() 会返回一个 AggregateError，其中包含所有 rejected 的 Promise 的错误。
-    // EvalError  when an error occurs during the evaluation of JavaScript code.
-    // ReferenceError  when a non-existent variable is referenced.
-    // SyntaxError  when a syntax error occurs while parsing code in eval().
-    // URIError  when encodeURI() or decodeURI() are passed invalid parameters.
-    // InternalError  when an internal error in the JavaScript engine is thrown. E.g. "too much recursion".
-    // DOMException  when an error occurs in the DOM.
+    Errors.IllegalState = create({
+        status: 500,
+        message: "Illegal State"
+    });
+    Errors.UnsupportedOperation = create({
+        status: 500,
+        message: "Unsupported Operation"
+    });
+    Errors.IllegalArgument = create({
+        status: 400,
+        message: "Illegal Argument"
+    });
+    Errors.InvalidType = create({
+        status: 400,
+        message: "Invalid Type"
+    });
     Errors.resolvers = [];
     function create(init) {
         return new DetailHolder(init);
@@ -150,37 +112,56 @@ https://www.npmjs.com/package/pony-cause
         if (res.ok) {
             return res;
         }
-        throw create({
+        throw create(_object_spread_props(_object_spread({
             description: res.statusText,
-            status: res.status,
-            ...o,
-            metadata: {
-                ...o?.metadata,
+            status: res.status
+        }, o), {
+            metadata: _object_spread_props(_object_spread({}, o === null || o === void 0 ? void 0 : o.metadata), {
                 response: res
-            }
-        }).asError();
+            })
+        })).asError();
     }
     Errors.ok = ok;
     function resolve(e) {
-        if (e instanceof DetailHolder) {
+        if (_instanceof(e, DetailHolder)) {
             return e;
         }
-        if (e instanceof DetailError) {
+        if (_instanceof(e, DetailError)) {
             return e.detail;
         }
-        for (const resolver of Errors.resolvers){
-            const r = resolver(e);
-            if (r) {
-                return r;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for (var _iterator = Errors.resolvers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                var resolver = _step.value;
+                var r = resolver(e);
+                if (r) {
+                    return r;
+                }
+            }
+        }
+        catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        }
+        finally {
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            }
+            finally {
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
             }
         }
-        if (e instanceof Error) {
-            const { message, code, status } = e;
+        if (isError(e)) {
+            var message = e.message, code = e.code, status = e.status;
             // can get status from NestJS HttpException
             return new DetailHolder({
-                message,
+                message: message,
                 status: parseInt(status) || 500,
-                code,
+                code: code,
                 cause: e
             });
         }
@@ -191,12 +172,30 @@ https://www.npmjs.com/package/pony-cause
         });
     }
     Errors.resolve = resolve;
-})(Errors || (Errors = {})); // interface ZodError {
- //   path: Array<string | number>;
- //   message: string;
- //   code: string;
- //   expected?: any;
- //   received?: any;
- // }
-
-//# sourceMappingURL=Errors.js.map
+    function isError(e) {
+        if ("isError" in Error) {
+            // will handle cross-realm
+            return Error.isError(e);
+        }
+        return _instanceof(e, Error);
+    }
+    /**
+     * Check if the given value is an Error
+     * @see https://github.com/tc39/proposal-is-error
+     */ Errors.isError = isError;
+    function isAbort(e) {
+        if (!isError(e)) {
+            return false;
+        }
+        return e.name === "AbortError";
+    }
+    Errors.isAbort = isAbort;
+    function isTimeout(e) {
+        if (!isError(e)) {
+            return false;
+        }
+        return e.name === "TimeoutError" || e.name === "Timeout";
+    }
+    Errors.isTimeout = isTimeout;
+})(Errors || (Errors = {}));
+export var Errors;

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