@wener/common 1.0.4 → 2.0.1

package/lib/password/createBase64PasswordAlgorithm.js

@@ -1,14 +1,147 @@
-import { ArrayBuffers } from "@wener/utils";
-export function createBase64PasswordAlgorithm({ id = 'base64' } = {}) {
+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 { ArrayBuffers } from '@wener/utils';
+export function createBase64PasswordAlgorithm() {
+    var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref_id = _ref.id, id = _ref_id === void 0 ? 'base64' : _ref_id;
     return {
         name: id,
-        async hash (password) {
-            return `$${id}$$${ArrayBuffers.toBase64(password).replace(/=/g, '')}`;
+        hash: function hash(password) {
+            return _async_to_generator(function() {
+                return _ts_generator(this, function(_state) {
+                    return [
+                        2,
+                        "$".concat(id, "$$").concat(ArrayBuffers.toBase64(password).replace(/=/g, ''))
+                    ];
+                });
+            })();
         },
-        async verify (password, hash, opts) {
-            return Boolean(opts.hash) && ArrayBuffers.toString(opts.hash) === password;
+        verify: function verify(password, hash, opts) {
+            return _async_to_generator(function() {
+                return _ts_generator(this, function(_state) {
+                    return [
+                        2,
+                        Boolean(opts.hash) && ArrayBuffers.toString(opts.hash) === password
+                    ];
+                });
+            })();
         }
     };
 }
-
-//# sourceMappingURL=createBase64PasswordAlgorithm.js.map

package/lib/password/createBcryptPasswordAlgorithm.js

@@ -1,20 +1,175 @@
-export function createBcryptPasswordAlgorithm({ // provider = () => import('bcrypt').then((v) => v.default),
-provider = ()=>import("bcryptjs").then((v)=>v.default) } = {}) {
+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
+        };
+    }
+}
+export function createBcryptPasswordAlgorithm() {
+    var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref_provider = _ref.// provider = () => import('bcrypt').then((v) => v.default),
+    provider, provider = _ref_provider === void 0 ? function() {
+        return import('bcryptjs').then(function(v) {
+            return v.default;
+        });
+    } : _ref_provider;
     // bcrypt or bcryptjs
     return {
         name: 'bcrypt',
-        async hash (password, opts) {
-            const { hash } = await provider();
-            return hash(password, opts?.rounds ?? 10);
+        hash: function hash(password, opts) {
+            return _async_to_generator(function() {
+                var hash, _opts_rounds;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                provider()
+                            ];
+                        case 1:
+                            hash = _state.sent().hash;
+                            return [
+                                2,
+                                hash(password, (_opts_rounds = opts === null || opts === void 0 ? void 0 : opts.rounds) !== null && _opts_rounds !== void 0 ? _opts_rounds : 10)
+                            ];
+                    }
+                });
+            })();
         },
-        async verify (password, hash) {
-            const { compare } = await provider();
-            if (hash.startsWith('$2y$')) {
-                hash = hash.replace(/^\$2y\$/, '$2a$');
-            }
-            return compare(password, hash);
+        verify: function verify(password, hash) {
+            return _async_to_generator(function() {
+                var compare;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                provider()
+                            ];
+                        case 1:
+                            compare = _state.sent().compare;
+                            if (hash.startsWith('$2y$')) {
+                                hash = hash.replace(/^\$2y\$/, '$2a$');
+                            }
+                            return [
+                                2,
+                                compare(password, hash)
+                            ];
+                    }
+                });
+            })();
         }
     };
 }
-
-//# sourceMappingURL=createBcryptPasswordAlgorithm.js.map

package/lib/password/createPBKDF2PasswordAlgorithm.js

@@ -1,54 +1,236 @@
+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 _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    }
+    else {
+        return left instanceof right;
+    }
+}
+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 { PHC } from "./PHC.js";
-export function createPBKDF2PasswordAlgorithm({ id, digest, iterations = 100000, saltlen = 16, keylen = digest === "SHA-256" ? 32 : 64 }) {
+export function createPBKDF2PasswordAlgorithm(param) {
+    var id = param.id, digest = param.digest, _param_iterations = param.iterations, iterations = _param_iterations === void 0 ? 100000 : _param_iterations, _param_saltlen = param.saltlen, saltlen = _param_saltlen === void 0 ? 16 : _param_saltlen, _param_keylen = param.keylen, keylen = _param_keylen === void 0 ? digest === "SHA-256" ? 32 : 64 : _param_keylen;
     return {
         name: id,
-        async hash(password, opts) {
-            let salt;
-            if (opts?.salt) {
-                salt = opts.salt;
-            }
-            else {
-                salt = new Uint8Array(saltlen);
-                crypto.getRandomValues(salt);
-            }
-            const rounds = opts?.rounds ?? iterations;
-            let key = await crypto.subtle.importKey("raw", new TextEncoder().encode(password), "PBKDF2", false, [
-                "deriveBits"
-            ]);
-            let hash = await crypto.subtle.deriveBits({
-                name: "PBKDF2",
-                iterations: rounds,
-                salt,
-                hash: digest
-            }, key, keylen * 8);
-            return PHC.serialize({
-                id: opts?.id ?? id,
-                params: {
-                    rounds
-                },
-                salt,
-                hash: new Uint8Array(hash)
-            });
+        hash: function hash(password, opts) {
+            return _async_to_generator(function () {
+                var salt, _opts_rounds, rounds, key, hash, _opts_id;
+                return _ts_generator(this, function (_state) {
+                    switch (_state.label) {
+                        case 0:
+                            if (opts === null || opts === void 0 ? void 0 : opts.salt) {
+                                salt = opts.salt;
+                            }
+                            else {
+                                salt = new Uint8Array(saltlen);
+                                crypto.getRandomValues(salt);
+                            }
+                            rounds = (_opts_rounds = opts === null || opts === void 0 ? void 0 : opts.rounds) !== null && _opts_rounds !== void 0 ? _opts_rounds : iterations;
+                            return [
+                                4,
+                                crypto.subtle.importKey("raw", new TextEncoder().encode(password), "PBKDF2", false, [
+                                    "deriveBits"
+                                ])
+                            ];
+                        case 1:
+                            key = _state.sent();
+                            return [
+                                4,
+                                crypto.subtle.deriveBits({
+                                    name: "PBKDF2",
+                                    iterations: rounds,
+                                    salt: salt,
+                                    hash: digest
+                                }, key, keylen * 8)
+                            ];
+                        case 2:
+                            hash = _state.sent();
+                            return [
+                                2,
+                                PHC.serialize({
+                                    id: (_opts_id = opts === null || opts === void 0 ? void 0 : opts.id) !== null && _opts_id !== void 0 ? _opts_id : id,
+                                    params: {
+                                        rounds: rounds
+                                    },
+                                    salt: salt,
+                                    hash: new Uint8Array(hash)
+                                })
+                            ];
+                    }
+                });
+            })();
         },
-        async verify(password, _, opts) {
-            const rounds = opts?.params?.rounds ?? iterations;
-            const salt = opts.salt;
-            const storedHash = opts.hash;
-            Errors.BadRequest.check(typeof rounds === "number", "Invalid rounds");
-            Errors.BadRequest.check(salt instanceof Uint8Array, "Invalid salt");
-            Errors.BadRequest.check(storedHash instanceof Uint8Array, "Invalid hash");
-            let key = await crypto.subtle.importKey("raw", new TextEncoder().encode(password), "PBKDF2", false, [
-                "deriveBits"
-            ]);
-            let hash = await crypto.subtle.deriveBits({
-                name: "PBKDF2",
-                iterations: rounds,
-                salt,
-                hash: digest
-            }, key, storedHash.length * 8);
-            return new Uint8Array(hash).every((v, i) => v === storedHash[i]);
+        verify: function verify(password, _, opts) {
+            return _async_to_generator(function () {
+                var _opts_params, _opts_params_rounds, rounds, salt, storedHash, key, hash;
+                return _ts_generator(this, function (_state) {
+                    switch (_state.label) {
+                        case 0:
+                            rounds = (_opts_params_rounds = opts === null || opts === void 0 ? void 0 : (_opts_params = opts.params) === null || _opts_params === void 0 ? void 0 : _opts_params.rounds) !== null && _opts_params_rounds !== void 0 ? _opts_params_rounds : iterations;
+                            salt = opts.salt;
+                            storedHash = opts.hash;
+                            Errors.BadRequest.check(typeof rounds === "number", "Invalid rounds");
+                            Errors.BadRequest.check(_instanceof(salt, Uint8Array), "Invalid salt");
+                            Errors.BadRequest.check(_instanceof(storedHash, Uint8Array), "Invalid hash");
+                            return [
+                                4,
+                                crypto.subtle.importKey("raw", new TextEncoder().encode(password), "PBKDF2", false, [
+                                    "deriveBits"
+                                ])
+                            ];
+                        case 1:
+                            key = _state.sent();
+                            return [
+                                4,
+                                crypto.subtle.deriveBits({
+                                    name: "PBKDF2",
+                                    iterations: rounds,
+                                    salt: salt,
+                                    hash: digest
+                                }, key, storedHash.length * 8)
+                            ];
+                        case 2:
+                            hash = _state.sent();
+                            return [
+                                2,
+                                new Uint8Array(hash).every(function (v, i) {
+                                    return v === storedHash[i];
+                                })
+                            ];
+                    }
+                });
+            })();
         }
     };
 }
-//# sourceMappingURL=createPBKDF2PasswordAlgorithm.js.map