@wener/common 1.0.5 → 2.0.2

package/lib/password/Password.js

@@ -1,8 +1,200 @@
+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 _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 _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 _object_without_properties(source, excluded) {
+    if (source == null)
+        return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for (i = 0; i < sourceSymbolKeys.length; i++) {
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0)
+                continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key))
+                continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null)
+        return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for (i = 0; i < sourceKeys.length; i++) {
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0)
+            continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+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 { Errors } from "@wener/utils";
 import { createPBKDF2PasswordAlgorithm } from "./createPBKDF2PasswordAlgorithm.js";
 import { PHC } from "./PHC.js";
 (function (Password) {
-    const Algorithms = {
+    var Algorithms = {
         1: "md5",
         "2a": "bcrypt",
         "2b": "bcrypt",
@@ -12,9 +204,9 @@ import { PHC } from "./PHC.js";
         6: "sha512",
         7: "scrypt"
     };
-    let DefaultAlgorithm = "6";
+    var DefaultAlgorithm = "6";
     function setDefaultAlgorithm(algorithm) {
-        Errors.BadRequest.check(Algorithms[algorithm], `Unknown algorithm ${algorithm}`);
+        Errors.BadRequest.check(Algorithms[algorithm], "Unknown algorithm ".concat(algorithm));
         DefaultAlgorithm = algorithm;
     }
     Password.setDefaultAlgorithm = setDefaultAlgorithm;
@@ -25,8 +217,28 @@ import { PHC } from "./PHC.js";
     function addAlgorithm(algorithm) {
         Algorithms[algorithm.name] = algorithm;
         if (algorithm.ids) {
-            for (const id of algorithm.ids) {
-                Algorithms[id] = algorithm;
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for (var _iterator = algorithm.ids[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                    var id = _step.value;
+                    Algorithms[id] = algorithm;
+                }
+            }
+            catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            }
+            finally {
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                }
+                finally {
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
             }
         }
     }
@@ -39,45 +251,98 @@ import { PHC } from "./PHC.js";
         id: "sha512",
         digest: "SHA-512"
     }));
-    async function parse(hash) {
-        return PHC.deserialize(hash);
+    function parse(hash) {
+        return _async_to_generator(function () {
+            return _ts_generator(this, function (_state) {
+                return [
+                    2,
+                    PHC.deserialize(hash)
+                ];
+            });
+        })();
     }
     Password.parse = parse;
     function resolveAlgorithm(id) {
-        let f = id;
+        var f = id;
         while (typeof f === "string") {
             f = Algorithms[f];
         }
         if (!f) {
-            throw new Error(`Unknown algorithm ${id}`);
+            throw new Error("Unknown algorithm ".concat(id));
         }
         return f;
     }
-    async function check(password, hash) {
-        let res = await parse(hash);
-        let f = resolveAlgorithm(res.id);
-        return {
-            result: f.verify(password, hash, res),
-            parsed: res
-        };
+    function validate(password, hash) {
+        return _async_to_generator(function () {
+            var res, f, _tmp;
+            return _ts_generator(this, function (_state) {
+                switch (_state.label) {
+                    case 0:
+                        return [
+                            4,
+                            parse(hash)
+                        ];
+                    case 1:
+                        res = _state.sent();
+                        f = resolveAlgorithm(res.id);
+                        _tmp = {};
+                        return [
+                            4,
+                            f.verify(password, hash, res)
+                        ];
+                    case 2:
+                        return [
+                            2,
+                            (_tmp.result = _state.sent(), _tmp.parsed = res, _tmp)
+                        ];
+                }
+            });
+        })();
     }
-    Password.check = check;
-    async function verify(password, hash) {
-        let res = await parse(hash);
-        let f = resolveAlgorithm(res.id);
-        return f.verify(password, hash, res);
+    Password.validate = validate;
+    function verify(password, hash) {
+        return _async_to_generator(function () {
+            var res, f;
+            return _ts_generator(this, function (_state) {
+                switch (_state.label) {
+                    case 0:
+                        return [
+                            4,
+                            parse(hash)
+                        ];
+                    case 1:
+                        res = _state.sent();
+                        f = resolveAlgorithm(res.id);
+                        return [
+                            2,
+                            f.verify(password, hash, res)
+                        ];
+                }
+            });
+        })();
     }
     Password.verify = verify;
-    async function hash(password, { algorithm, ...opts } = {}) {
-        let f = resolveAlgorithm(algorithm ?? DefaultAlgorithm);
-        let id = algorithm ?? DefaultAlgorithm;
-        typeof id !== "string" && (id = f.name);
-        return f.hash(password, {
-            id,
-            ...opts
-        });
+    function hash(_0) {
+        return _async_to_generator(function (password) {
+            var _param, algorithm, opts, f, id;
+            var _arguments = arguments;
+            return _ts_generator(this, function (_state) {
+                _param = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {};
+                algorithm = _param.algorithm, opts = _object_without_properties(_param, [
+                    "algorithm"
+                ]);
+                f = resolveAlgorithm(algorithm !== null && algorithm !== void 0 ? algorithm : DefaultAlgorithm);
+                id = algorithm !== null && algorithm !== void 0 ? algorithm : DefaultAlgorithm;
+                typeof id !== "string" && (id = f.name);
+                return [
+                    2,
+                    f.hash(password, _object_spread({
+                        id: id
+                    }, opts))
+                ];
+            });
+        }).apply(this, arguments);
     }
     Password.hash = hash;
 })(Password || (Password = {}));
 export var Password;
-//# sourceMappingURL=Password.js.map