@bitblit/ratchet-common 4.0.80-alpha

package/dist/cjs/2d/line-2d.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/2d/plane-2d.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/2d/point-2d.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/2d/poly-line-2d.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/2d/ratchet-2d.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ratchet2d = void 0;
+const boolean_ratchet_1 = require("../lang/boolean-ratchet");
+class Ratchet2d {
+    constructor() { }
+    static translateToOriginVector(points) {
+        let rval = null;
+        if (Ratchet2d.validPoints(points)) {
+            rval = {
+                x: null,
+                y: null,
+            };
+            points.forEach((p) => {
+                rval.x = rval.x === null || p.x < rval.x ? p.x : rval.x;
+                rval.y = rval.y === null || p.y < rval.y ? p.y : rval.y;
+            });
+            rval.x *= -1;
+            rval.y *= -1;
+        }
+        return rval;
+    }
+    static minimalContainingPlane(points) {
+        let rval = null;
+        if (Ratchet2d.validPoints(points)) {
+            rval = {
+                width: 0,
+                height: 0,
+            };
+            points.forEach((p) => {
+                rval.width = Math.max(rval.width, p.x + 1);
+                rval.height = Math.max(rval.height, p.y + 1);
+            });
+        }
+        return rval;
+    }
+    static scaleVector(src, dst) {
+        let rval = null;
+        if (Ratchet2d.validPlane(src) && Ratchet2d.validPlane(dst)) {
+            rval = {
+                x: dst.width / src.width,
+                y: dst.height / src.height,
+            };
+        }
+        return rval;
+    }
+    static samePoint(p1, p2) {
+        return !!p1 && !!p2 && p1.x === p2.x && p1.y === p2.y;
+    }
+    static atLeastOneDimensionShared(p1, p2) {
+        return !!p1 && !!p2 && (p1.x === p2.x || p1.y === p2.y);
+    }
+    static validPlane(plane) {
+        return !!plane && !!plane.height && !!plane.width;
+    }
+    static validLine(line) {
+        return !!line && Ratchet2d.validPoint(line.p1) && Ratchet2d.validPoint(line.p2) && !Ratchet2d.samePoint(line.p1, line.p2);
+    }
+    static validLines(lines) {
+        return !!lines && boolean_ratchet_1.BooleanRatchet.allTrue(lines.map((l) => Ratchet2d.validLine(l)));
+    }
+    static validPolyLine(pline) {
+        var _a;
+        return !!pline && ((_a = pline.pts) === null || _a === void 0 ? void 0 : _a.length) > 1 && boolean_ratchet_1.BooleanRatchet.allTrue(pline.pts.map((p) => Ratchet2d.validPoint(p)));
+    }
+    static polyLineToLines(pline) {
+        let rval = null;
+        if (Ratchet2d.validPolyLine(pline)) {
+            rval = [];
+            for (let i = 1; i < pline.pts.length; i++) {
+                rval.push({ p1: pline.pts[i - 1], p2: pline.pts[i] });
+            }
+        }
+        return rval;
+    }
+    static lastPointOnPolyLine(polyLine) {
+        return Ratchet2d.validPolyLine(polyLine) ? polyLine.pts[polyLine.pts.length - 1] : null;
+    }
+    static lineToPolyLine(line) {
+        return Ratchet2d.validLine(line) ? { pts: [line.p1, line.p2] } : null;
+    }
+    static linesToPolyLines(lines) {
+        let rval = null;
+        if (Ratchet2d.validLines(lines)) {
+            rval = [];
+            let currentPLine = Ratchet2d.lineToPolyLine(lines[0]);
+            for (let i = 1; i < lines.length; i++) {
+                if (Ratchet2d.samePoint(Ratchet2d.lastPointOnPolyLine(currentPLine), lines[i].p1)) {
+                    currentPLine.pts.push(lines[i].p2);
+                }
+                else {
+                    rval.push(currentPLine);
+                    currentPLine = Ratchet2d.lineToPolyLine(lines[i]);
+                }
+            }
+            rval.push(currentPLine);
+        }
+        return rval;
+    }
+    static validPoint(pt) {
+        return !!pt && pt.x != null && pt.x != undefined && pt.y !== null && pt.y !== undefined;
+    }
+    static validPoints(pt) {
+        return (!!pt &&
+            boolean_ratchet_1.BooleanRatchet.allTrue(pt.map((p) => Ratchet2d.validPoint(p)), false));
+    }
+    static planeContainsPoint(pt, plane) {
+        return Ratchet2d.validPlane(plane) && Ratchet2d.validPoint(pt) && pt.x >= 0 && pt.x < plane.width && pt.y >= 0 && pt.y < plane.height;
+    }
+    static planeContainsPoints(pt, plane) {
+        return pt && pt.map((p) => Ratchet2d.planeContainsPoint(p, plane)).reduce((a, i) => a && i, true);
+    }
+    static linesToPoints(lines) {
+        let rval = null;
+        if (Ratchet2d.validLines(lines)) {
+            rval = lines.map((l) => [l.p1, l.p2]).flat();
+        }
+        return rval;
+    }
+    static pointsToLines(points) {
+        let rval = null;
+        if (Ratchet2d.validPoints(points)) {
+            if (points.length % 2 == 0) {
+                rval = [];
+                for (let i = 0; i < points.length; i += 2) {
+                    rval.push({ p1: points[i], p2: points[i + 1] });
+                }
+            }
+            else {
+                throw new Error('Cannot convert non-even array of points into lines');
+            }
+        }
+        return rval;
+    }
+    static rotateRightAboutOrigin90Degrees(points, times = 1) {
+        let rval = null;
+        let translate = { x: 0, y: 0 };
+        if (Ratchet2d.validPoints(points)) {
+            rval = Object.assign([], points);
+            translate = Ratchet2d.translateToOriginVector(rval);
+            rval = Ratchet2d.translate(rval, translate);
+            let plane = Ratchet2d.minimalContainingPlane(rval);
+            rval = Ratchet2d.xToY(rval);
+            plane = { width: plane.height, height: plane.width };
+            translate = { x: translate.y * -1, y: translate.x * -1 };
+            rval = Ratchet2d.mirrorPointsOnPlane(rval, plane, true, false);
+            rval = Ratchet2d.translate(rval, translate);
+        }
+        const timesToRotate = times > 4 ? times % 4 : times;
+        if (timesToRotate > 1) {
+            rval = Ratchet2d.rotateRightAboutOrigin90Degrees(rval, timesToRotate - 1);
+        }
+        return rval;
+    }
+    static planeContainsLines(lines, plane) {
+        return lines && Ratchet2d.planeContainsPoints(lines.map((l) => [l.p1, l.p2]).flat(), plane);
+    }
+    static planeContainsPolyLine(pline, plane) {
+        return Ratchet2d.planeContainsLines(Ratchet2d.polyLineToLines(pline), plane);
+    }
+    static planeContainsLine(line, plane) {
+        return (Ratchet2d.validPlane(plane) &&
+            Ratchet2d.validLine(line) &&
+            Ratchet2d.planeContainsPoint(line.p1, plane) &&
+            Ratchet2d.planeContainsPoint(line.p2, plane));
+    }
+    static xToY(points) {
+        let rval = null;
+        if (Ratchet2d.validPoints(points)) {
+            rval = points.map((p) => {
+                const next = { x: p.y, y: p.x };
+                return next;
+            });
+        }
+        return rval;
+    }
+    static translate(points, xlate) {
+        let rval = null;
+        if (Ratchet2d.validPoints(points) && Ratchet2d.validPoint(xlate)) {
+            rval = points.map((p) => {
+                const next = {
+                    x: p.x + xlate.x,
+                    y: p.y + xlate.y,
+                };
+                return next;
+            });
+        }
+        return rval;
+    }
+    static mirrorPointsOnPlane(points, src, mirrorX, mirrorY) {
+        let rval = null;
+        if (Ratchet2d.validPoints(points) && Ratchet2d.validPlane(src)) {
+            if (mirrorX || mirrorY) {
+                rval = points.map((p) => {
+                    const next = {
+                        x: mirrorX ? src.width - 1 - p.x : p.x,
+                        y: mirrorY ? src.height - 1 - p.y : p.y,
+                    };
+                    return next;
+                });
+            }
+            else {
+                rval = Object.assign([], points);
+            }
+        }
+        return rval;
+    }
+    static transformPointsToNewPlane(points, src, dst) {
+        let rval = null;
+        if (Ratchet2d.validPoints(points) && Ratchet2d.validPlane(src) && Ratchet2d.validPlane(dst)) {
+            const scale = Ratchet2d.scaleVector(src, dst);
+            rval = points.map((p) => {
+                const next = { x: p.x * scale.x, y: p.y * scale.y };
+                return next;
+            });
+            rval = Ratchet2d.mirrorPointsOnPlane(rval, dst, dst.rightToLeft !== src.rightToLeft, dst.topToBottom !== src.topToBottom);
+        }
+        return rval;
+    }
+    static transformPointToNewPlane(point, src, dst) {
+        const tmp = Ratchet2d.transformPointsToNewPlane([point], src, dst);
+        return tmp.length === 1 ? tmp[0] : null;
+    }
+    static transformLines(lines, src, dst) {
+        return null;
+    }
+    static fitCurve(curveDef, inputX) {
+        curveDef.sort((a, b) => {
+            return a.x - b.x;
+        });
+        if (inputX <= curveDef[0].x) {
+            return curveDef[0].y;
+        }
+        else if (inputX >= curveDef[curveDef.length - 1].x) {
+            return curveDef[curveDef.length - 1].y;
+        }
+        else {
+            let idx = 0;
+            while (curveDef[idx + 1].x < inputX) {
+                idx++;
+            }
+            const xSpread = curveDef[idx + 1].x - curveDef[idx].x;
+            const ySpread = curveDef[idx + 1].y - curveDef[idx].y;
+            const pct = (inputX - curveDef[idx].x) / xSpread;
+            const yAdd = pct * ySpread;
+            return curveDef[idx].y + yAdd;
+        }
+    }
+}
+exports.Ratchet2d = Ratchet2d;

package/dist/cjs/build/build-information.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/build/ratchet-common-info.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RatchetInfo = void 0;
+class RatchetInfo {
+    constructor() { }
+    static buildInformation() {
+        const val = {
+            version: '80',
+            hash: '10fcb761c2fa4186df89e527e948f5780a4e14ac',
+            branch: 'alpha-2023-03-12-2',
+            tag: 'alpha-2023-03-12-2',
+            timeBuiltISO: '2023-03-12T20:00:51-0700',
+            notes: '',
+        };
+        return val;
+    }
+}
+exports.RatchetInfo = RatchetInfo;

package/dist/cjs/histogram/histogram-entry.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/histogram/histogram.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Histogram = void 0;
+class Histogram {
+    constructor() {
+        this.entries = [];
+    }
+    update(val, addValue = 1) {
+        if (val) {
+            const entry = this.entries.find((e) => e.item === val);
+            if (entry) {
+                entry.count += addValue;
+            }
+            else {
+                this.entries.push({
+                    item: val,
+                    count: addValue,
+                });
+            }
+        }
+    }
+    sort() {
+        this.entries.sort((a, b) => {
+            let rval = b.count - a.count;
+            if (rval === 0) {
+                rval = String(b.item).localeCompare(String(a.item));
+            }
+            return rval;
+        });
+    }
+    sortKeys() {
+        this.entries.sort((a, b) => String(b.item).localeCompare(String(a.item)));
+    }
+    reverse() {
+        this.entries.reverse();
+    }
+    getEntries() {
+        return this.entries;
+    }
+    getTotalCount() {
+        let rval = 0;
+        this.entries.forEach((h) => (rval += h.count));
+        return rval;
+    }
+    countForValue(val) {
+        const entry = this.entries.find((test) => test.item === val);
+        return entry ? entry.count : 0;
+    }
+    percentForValue(val) {
+        const total = this.getTotalCount();
+        return total === 0 ? 0 : this.countForValue(val) / total;
+    }
+}
+exports.Histogram = Histogram;

package/dist/cjs/index.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./2d/line-2d"), exports);
+tslib_1.__exportStar(require("./2d/plane-2d"), exports);
+tslib_1.__exportStar(require("./2d/point-2d"), exports);
+tslib_1.__exportStar(require("./2d/poly-line-2d"), exports);
+tslib_1.__exportStar(require("./2d/ratchet-2d"), exports);
+tslib_1.__exportStar(require("./build/build-information"), exports);
+tslib_1.__exportStar(require("./build/ratchet-common-info"), exports);
+tslib_1.__exportStar(require("./histogram/histogram-entry"), exports);
+tslib_1.__exportStar(require("./histogram/histogram"), exports);
+tslib_1.__exportStar(require("./jwt/common-jwt-token"), exports);
+tslib_1.__exportStar(require("./jwt/expired-jwt-handling"), exports);
+tslib_1.__exportStar(require("./jwt/jwt-ratchet-like"), exports);
+tslib_1.__exportStar(require("./jwt/jwt-ratchet"), exports);
+tslib_1.__exportStar(require("./jwt/jwt-token-base"), exports);
+tslib_1.__exportStar(require("./lang/array-ratchet"), exports);
+tslib_1.__exportStar(require("./lang/base64-ratchet"), exports);
+tslib_1.__exportStar(require("./lang/boolean-ratchet"), exports);
+tslib_1.__exportStar(require("./lang/composite-last-success-provider"), exports);
+tslib_1.__exportStar(require("./lang/date-ratchet"), exports);
+tslib_1.__exportStar(require("./lang/duration-ratchet"), exports);
+tslib_1.__exportStar(require("./lang/enum-ratchet"), exports);
+tslib_1.__exportStar(require("./lang/error-ratchet"), exports);
+tslib_1.__exportStar(require("./lang/expiring-object"), exports);
+tslib_1.__exportStar(require("./lang/geolocation-ratchet"), exports);
+tslib_1.__exportStar(require("./lang/global-ratchet"), exports);
+tslib_1.__exportStar(require("./lang/key-value"), exports);
+tslib_1.__exportStar(require("./lang/last-success-provider"), exports);
+tslib_1.__exportStar(require("./lang/map-ratchet"), exports);
+tslib_1.__exportStar(require("./lang/no"), exports);
+tslib_1.__exportStar(require("./lang/number-ratchet"), exports);
+tslib_1.__exportStar(require("./lang/parsed-url"), exports);
+tslib_1.__exportStar(require("./lang/promise-ratchet"), exports);
+tslib_1.__exportStar(require("./lang/require-ratchet"), exports);
+tslib_1.__exportStar(require("./lang/stop-watch"), exports);
+tslib_1.__exportStar(require("./lang/string-ratchet"), exports);
+tslib_1.__exportStar(require("./lang/time-zone-ratchet"), exports);
+tslib_1.__exportStar(require("./lang/timeout-token"), exports);
+tslib_1.__exportStar(require("./lang/transform-ratchet"), exports);
+tslib_1.__exportStar(require("./logger/classic-single-line-log-message-formatter"), exports);
+tslib_1.__exportStar(require("./logger/log-message-builder"), exports);
+tslib_1.__exportStar(require("./logger/log-message-format-type"), exports);
+tslib_1.__exportStar(require("./logger/log-message-formatter"), exports);
+tslib_1.__exportStar(require("./logger/log-message-processor"), exports);
+tslib_1.__exportStar(require("./logger/log-message"), exports);
+tslib_1.__exportStar(require("./logger/log-snapshot"), exports);
+tslib_1.__exportStar(require("./logger/logger-instance"), exports);
+tslib_1.__exportStar(require("./logger/logger-level-name"), exports);
+tslib_1.__exportStar(require("./logger/logger-meta"), exports);
+tslib_1.__exportStar(require("./logger/logger-options"), exports);
+tslib_1.__exportStar(require("./logger/logger-output-function"), exports);
+tslib_1.__exportStar(require("./logger/logger-ring-buffer"), exports);
+tslib_1.__exportStar(require("./logger/logger-util"), exports);
+tslib_1.__exportStar(require("./logger/logger"), exports);
+tslib_1.__exportStar(require("./logger/none-log-message-formatter"), exports);
+tslib_1.__exportStar(require("./logger/structured-json-log-message-formatter"), exports);
+tslib_1.__exportStar(require("./network/browser-local-ip-provider"), exports);
+tslib_1.__exportStar(require("./network/fixed-local-ip-provider"), exports);
+tslib_1.__exportStar(require("./network/local-ip-provider"), exports);
+tslib_1.__exportStar(require("./network/network-ratchet"), exports);
+tslib_1.__exportStar(require("./stream/buffer-writable"), exports);
+tslib_1.__exportStar(require("./stream/stream-ratchet"), exports);
+tslib_1.__exportStar(require("./stream/string-writable"), exports);
+tslib_1.__exportStar(require("./third-party/google/google-recaptcha-ratchet"), exports);
+tslib_1.__exportStar(require("./third-party/twilio/twilio-ratchet"), exports);
+tslib_1.__exportStar(require("./transform/built-in-transforms"), exports);
+tslib_1.__exportStar(require("./transform/transform-rule"), exports);
+tslib_1.__exportStar(require("./tx/transaction-configuration"), exports);
+tslib_1.__exportStar(require("./tx/transaction-final-state"), exports);
+tslib_1.__exportStar(require("./tx/transaction-ratchet"), exports);
+tslib_1.__exportStar(require("./tx/transaction-result"), exports);
+tslib_1.__exportStar(require("./tx/transaction-step"), exports);

package/dist/cjs/jwt/common-jwt-token.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/jwt/expired-jwt-handling.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpiredJwtHandling = void 0;
+var ExpiredJwtHandling;
+(function (ExpiredJwtHandling) {
+    ExpiredJwtHandling[ExpiredJwtHandling["RETURN_NULL"] = 0] = "RETURN_NULL";
+    ExpiredJwtHandling[ExpiredJwtHandling["THROW_EXCEPTION"] = 1] = "THROW_EXCEPTION";
+    ExpiredJwtHandling[ExpiredJwtHandling["ADD_FLAG"] = 2] = "ADD_FLAG";
+})(ExpiredJwtHandling = exports.ExpiredJwtHandling || (exports.ExpiredJwtHandling = {}));

package/dist/cjs/jwt/jwt-ratchet-like.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/jwt/jwt-ratchet.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtRatchet = void 0;
+const tslib_1 = require("tslib");
+const jsonwebtoken_1 = tslib_1.__importDefault(require("jsonwebtoken"));
+const require_ratchet_1 = require("../lang/require-ratchet");
+const logger_1 = require("../logger/logger");
+const string_ratchet_1 = require("../lang/string-ratchet");
+const duration_ratchet_1 = require("../lang/duration-ratchet");
+const logger_level_name_1 = require("../logger/logger-level-name");
+const expired_jwt_handling_1 = require("./expired-jwt-handling");
+class JwtRatchet {
+    constructor(_encryptionKeyPromise, _decryptKeysPromise, _jtiGenerator = string_ratchet_1.StringRatchet.createType4Guid, _decryptOnlyKeyUseLogLevel = logger_level_name_1.LoggerLevelName.info, _parseFailureLogLevel = logger_level_name_1.LoggerLevelName.debug) {
+        this._encryptionKeyPromise = _encryptionKeyPromise;
+        this._decryptKeysPromise = _decryptKeysPromise;
+        this._jtiGenerator = _jtiGenerator;
+        this._decryptOnlyKeyUseLogLevel = _decryptOnlyKeyUseLogLevel;
+        this._parseFailureLogLevel = _parseFailureLogLevel;
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(_encryptionKeyPromise, 'encryptionKeyPromise');
+    }
+    get encryptionKeyPromise() {
+        return this._encryptionKeyPromise;
+    }
+    get decryptKeysPromise() {
+        return this._decryptKeysPromise;
+    }
+    get jtiGenerator() {
+        return this._jtiGenerator;
+    }
+    get decryptOnlyKeyUseLogLevel() {
+        return this._decryptOnlyKeyUseLogLevel;
+    }
+    get parseFailureLogLevel() {
+        return this._parseFailureLogLevel;
+    }
+    static hasExpiredFlag(ob) {
+        return ob && ob[JwtRatchet.EXPIRED_FLAG_NAME] === true;
+    }
+    static async invalidSafeDecode(payloadString, decryptKey, logLevel = logger_level_name_1.LoggerLevelName.silly) {
+        let rval = null;
+        try {
+            rval = jsonwebtoken_1.default.verify(payloadString, decryptKey, { ignoreExpiration: true });
+        }
+        catch (err) {
+            logger_1.Logger.logByLevel(logLevel, 'Caught %s - ignoring', err);
+        }
+        return rval;
+    }
+    static async secondsRemainingUntilExpiration(payloadString) {
+        let rval = null;
+        if (string_ratchet_1.StringRatchet.trimToNull(payloadString)) {
+            const output = await JwtRatchet.decodeTokenNoVerify(payloadString);
+            const nowSecond = Math.floor(Date.now() / 1000);
+            if (output.exp) {
+                const expSeconds = output.exp > nowSecond * 100 ? Math.floor(output.exp / 1000) : output.exp;
+                rval = Math.max(0, expSeconds - nowSecond);
+            }
+        }
+        return rval;
+    }
+    static async msRemainingUntilExpiration(payloadString) {
+        const secs = await JwtRatchet.secondsRemainingUntilExpiration(payloadString);
+        let rval = null;
+        if (secs !== null && secs !== undefined) {
+            rval = secs * 1000;
+        }
+        return rval;
+    }
+    async decodeToken(payloadString, expiredHandling = expired_jwt_handling_1.ExpiredJwtHandling.RETURN_NULL) {
+        const encKeys = await this.encryptionKeyArray();
+        let decKeys = Object.assign([], encKeys);
+        if (this.decryptKeysPromise) {
+            decKeys = decKeys.concat(await this.decryptKeysPromise);
+        }
+        const keysTried = [];
+        let payload = null;
+        for (let i = 0; i < decKeys.length && !payload; i++) {
+            keysTried.push(string_ratchet_1.StringRatchet.obscure(decKeys[i], 1, 1));
+            const logLevel = i === decKeys.length - 1 && this.parseFailureLogLevel ? this.parseFailureLogLevel : logger_level_name_1.LoggerLevelName.silly;
+            payload = await JwtRatchet.invalidSafeDecode(payloadString, decKeys[i], logLevel);
+            if (payload && i >= encKeys.length) {
+                logger_1.Logger.logByLevel(this.decryptOnlyKeyUseLogLevel, 'Used old key to decode token : %s', string_ratchet_1.StringRatchet.obscure(decKeys[i], 2));
+            }
+        }
+        if (payload) {
+            const nowSeconds = Math.floor(Date.now() / 1000);
+            const expSeconds = (payload === null || payload === void 0 ? void 0 : payload.exp) && payload.exp > nowSeconds * 100 ? Math.floor(payload.exp / 1000) : payload === null || payload === void 0 ? void 0 : payload.exp;
+            const nbfSeconds = (payload === null || payload === void 0 ? void 0 : payload.nbf) && payload.nbf > nowSeconds * 100 ? Math.floor(payload.nbf / 1000) : payload === null || payload === void 0 ? void 0 : payload.nbf;
+            if ((expSeconds && nowSeconds >= expSeconds) || (nbfSeconds && nowSeconds <= nbfSeconds)) {
+                const age = nowSeconds - expSeconds;
+                logger_1.Logger.debug('JWT token expired or before NBF : on %d, %s ago', payload.exp, duration_ratchet_1.DurationRatchet.formatMsDuration(age * 1000));
+                switch (expiredHandling) {
+                    case expired_jwt_handling_1.ExpiredJwtHandling.THROW_EXCEPTION:
+                        throw new Error('JWT Token was expired');
+                    case expired_jwt_handling_1.ExpiredJwtHandling.ADD_FLAG:
+                        payload[JwtRatchet.EXPIRED_FLAG_NAME] = true;
+                        break;
+                    default:
+                        payload = null;
+                        break;
+                }
+            }
+        }
+        else {
+            logger_1.Logger.warn('Unable to parse a payload (Tried %j) from : %s', keysTried, payloadString);
+        }
+        return payload;
+    }
+    async encryptionKeyArray() {
+        const encKey = await this.encryptionKeyPromise;
+        const rval = Array.isArray(encKey) ? encKey : [encKey];
+        if (rval.length < 1) {
+            throw new Error('Cannot create JwtRatchet with empty encryption key set');
+        }
+        return rval;
+    }
+    async selectRandomEncryptionKey() {
+        const encKey = await this.encryptionKeyArray();
+        const rval = encKey[Math.floor(Math.random() * encKey.length)];
+        return rval;
+    }
+    async createTokenString(payload, expirationSeconds, overrideEncryptionKey) {
+        const encKey = string_ratchet_1.StringRatchet.trimToNull(overrideEncryptionKey)
+            ? string_ratchet_1.StringRatchet.trimToNull(overrideEncryptionKey)
+            : await this.selectRandomEncryptionKey();
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(payload, 'payload');
+        payload.jti = this.jtiGenerator ? this.jtiGenerator() : null;
+        if (expirationSeconds) {
+            const nowSeconds = Math.floor(Date.now() / 1000);
+            const expires = nowSeconds + expirationSeconds;
+            logger_1.Logger.debug('Forcing expiration to %d', expires);
+            payload.exp = expires;
+        }
+        const token = jsonwebtoken_1.default.sign(payload, encKey);
+        return token;
+    }
+    async refreshJWTString(tokenString, allowExpired, expirationSeconds) {
+        const handling = allowExpired ? expired_jwt_handling_1.ExpiredJwtHandling.ADD_FLAG : expired_jwt_handling_1.ExpiredJwtHandling.THROW_EXCEPTION;
+        const payload = await this.decodeToken(tokenString, handling);
+        const originalDurationSeconds = payload.exp && payload.iat ? payload.exp - payload.iat : null;
+        const newExpirationSeconds = expirationSeconds || originalDurationSeconds;
+        JwtRatchet.removeJwtFields(payload);
+        JwtRatchet.removeExpiredFlag(payload);
+        const token = await this.createTokenString(payload, newExpirationSeconds);
+        return token;
+    }
+    static decodeTokenNoVerify(token) {
+        return jsonwebtoken_1.default.decode(token);
+    }
+    static removeJwtFields(ob) {
+        if (ob) {
+            ['iss', 'sub', 'aud', 'exp', 'nbf', 'iat', 'jti'].forEach((k) => {
+                delete ob[k];
+            });
+        }
+    }
+    static removeExpiredFlag(ob) {
+        if (ob) {
+            delete ob[JwtRatchet.EXPIRED_FLAG_NAME];
+        }
+    }
+}
+exports.JwtRatchet = JwtRatchet;
+JwtRatchet.EXPIRED_FLAG_NAME = '__jwtServiceExpiredFlag';

package/dist/cjs/jwt/jwt-token-base.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });