@wener/utils 1.1.53 → 1.1.54

package/lib/errors/Errors.js

@@ -1,2 +1,201 @@
-import * as _Errors from "./Errors.mod.js";
-export { _Errors as Errors };
+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 _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    }
+    else {
+        return left instanceof right;
+    }
+}
+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 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);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    }
+    else {
+        ownKeys(Object(source)).forEach(function (key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+import { DetailError, DetailHolder } from "./DetailError.js";
+(function (Errors) {
+    Errors.BadRequest = create({
+        status: 400
+    });
+    Errors.Unauthorized = create({
+        status: 403
+    });
+    Errors.Forbidden = create({
+        status: 403
+    });
+    Errors.NotFound = create({
+        status: 404
+    });
+    Errors.InternalServerError = create({
+        status: 500
+    });
+    Errors.NotImplemented = create({
+        status: 501
+    });
+    Errors.BadGateway = create({
+        status: 502,
+        message: "Bad Gateway"
+    });
+    Errors.ServiceUnavailable = create({
+        status: 503
+    });
+    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);
+    }
+    Errors.create = create;
+    function ok(res, o) {
+        if (res.ok) {
+            return res;
+        }
+        throw create(_object_spread_props(_object_spread({
+            description: res.statusText,
+            status: res.status
+        }, o), {
+            metadata: _object_spread_props(_object_spread({}, o === null || o === void 0 ? void 0 : o.metadata), {
+                response: res
+            })
+        })).asError();
+    }
+    Errors.ok = ok;
+    function resolve(e) {
+        if (_instanceof(e, DetailHolder)) {
+            return e;
+        }
+        if (_instanceof(e, DetailError)) {
+            return e.detail;
+        }
+        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 (isError(e)) {
+            var message = e.message, code = e.code, status = e.status;
+            // can get status from NestJS HttpException
+            return new DetailHolder({
+                message: message,
+                status: parseInt(status) || 500,
+                code: code,
+                cause: e
+            });
+        }
+        return new DetailHolder({
+            message: e.message,
+            status: 500,
+            cause: e
+        });
+    }
+    Errors.resolve = resolve;
+    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/index.js

@@ -21,23 +21,24 @@ export var sleep = Promises.sleep;
 export var isPromise = Promises.isPromise;
 export { timeout, TimeoutError } from "./asyncs/timeout.js";
 // langs
-export { isNil } from "./langs/isNil.js";
-export { shallowEqual } from "./langs/shallowEqual.js";
+export { classOf } from "./langs/classOf.js";
 export { deepEqual } from "./langs/deepEqual.js";
 export { deepFreeze } from "./langs/deepFreeze.js";
-export { classOf } from "./langs/classOf.js";
-export { shallowClone } from "./langs/shallowClone.js";
+export { getGlobalStates, setGlobalStates } from "./langs/getGlobalStates.js";
+export { getObjectId } from "./langs/getObjectId.js";
+export { ifPresent } from "./langs/ifPresent.js";
 export { isClass } from "./langs/isClass.js";
 export { isDefined } from "./langs/isDefined.js";
 export { isEmptyObject } from "./langs/isEmptyObject.js";
+export { isNil } from "./langs/isNil.js";
 export { isPlainObject } from "./langs/isPlainObject.js";
-export { ifPresent } from "./langs/ifPresent.js";
-export { parseBoolean } from "./langs/parseBoolean.js";
 export { maybeFunction } from "./langs/MaybeFunction.js";
 export { memoize } from "./langs/memoize.js";
 export { mixin } from "./langs/mixin.js";
-export { getObjectId } from "./langs/getObjectId.js";
-export { getGlobalStates, setGlobalStates } from "./langs/getGlobalStates.js";
+export { parseBoolean } from "./langs/parseBoolean.js";
+export { parseDate } from "./langs/parseDate.js";
+export { shallowClone } from "./langs/shallowClone.js";
+export { shallowEqual } from "./langs/shallowEqual.js";
 export { AsyncCloser } from "./langs/AsyncCloser.js";
 export { Closer } from "./langs/Closer.js";
 export { isUUID } from "./validations/isUUID.js";