@bitblit/ratchet-common 4.0.80-alpha

package/dist/cjs/network/local-ip-provider.js

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

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkRatchet = void 0;
+const logger_1 = require("../logger/logger");
+class NetworkRatchet {
+    static findLocalIp(useCache = true) {
+        logger_1.Logger.info('Attempting to find local IP (V 2)');
+        if (NetworkRatchet.LOCAL_IP && useCache) {
+            return Promise.resolve(NetworkRatchet.LOCAL_IP);
+        }
+        else {
+            if (typeof window !== 'undefined') {
+                return new Promise(function (resolve, reject) {
+                    try {
+                        const RTCPeerConnection = window['RTCPeerConnection'] || window['webkitRTCPeerConnection'] || window['mozRTCPeerConnection'];
+                        if (RTCPeerConnection) {
+                            const rtc = new RTCPeerConnection({ iceServers: [] });
+                            const addrs = Object.create(null);
+                            addrs['0.0.0.0'] = false;
+                            if (1 || window['mozRTCPeerConnection']) {
+                                rtc.createDataChannel('', { reliable: false });
+                            }
+                            rtc.onicecandidate = function (evt) {
+                                if (evt.candidate) {
+                                    NetworkRatchet.grepSDP('a=' + evt.candidate.candidate, addrs, resolve);
+                                }
+                            };
+                            rtc.createOffer(function (offerDesc) {
+                                NetworkRatchet.grepSDP(offerDesc.sdp, addrs, resolve);
+                                rtc.setLocalDescription(offerDesc);
+                            }, function (e) {
+                                logger_1.Logger.warn('Offer failed : %s', e);
+                                resolve(NetworkRatchet.updateLocalIP('FIND_UNSUPPORTED'));
+                            });
+                        }
+                        else {
+                            logger_1.Logger.warn('IP Address find not supported on this device');
+                            resolve(NetworkRatchet.updateLocalIP('FIND_UNSUPPORTED'));
+                        }
+                    }
+                    catch (err) {
+                        logger_1.Logger.warn('Error finding local ip address : %s', err);
+                        resolve(NetworkRatchet.updateLocalIP('ERROR'));
+                    }
+                });
+            }
+            else {
+                logger_1.Logger.warn('Window not found, cannot calculate local ip');
+                return Promise.resolve(NetworkRatchet.updateLocalIP('NO_WINDOW'));
+            }
+        }
+    }
+    static parseUrl(href) {
+        const match = href.match(/^(https?\:)\/\/(([^:\/?#]*)(?:\:([0-9]+))?)([\/]{0,1}[^?#]*)(\?[^#]*|)(#.*|)$/);
+        const rval = match &&
+            {
+                href: href,
+                protocol: match[1],
+                host: match[2],
+                hostname: match[3],
+                port: match[4],
+                pathname: match[5],
+                search: match[6],
+                hash: match[7],
+            };
+        return rval;
+    }
+    static updateLocalIP(newIp) {
+        NetworkRatchet.LOCAL_IP = newIp;
+        return NetworkRatchet.LOCAL_IP;
+    }
+    static grepSDP(sdp, addrs, resolve) {
+        const hosts = [];
+        sdp.split('\r\n').forEach(function (line) {
+            if (~line.indexOf('a=candidate')) {
+                const parts = line.split(' '), addr = parts[4], type = parts[7];
+                if (type === 'host') {
+                    NetworkRatchet.updateAddressList(addr, addrs, resolve);
+                }
+            }
+            else if (~line.indexOf('c=')) {
+                const parts = line.split(' '), addr = parts[2];
+                NetworkRatchet.updateAddressList(addr, addrs, resolve);
+            }
+        });
+    }
+    static updateAddressList(newAddr, addrs, resolve) {
+        if (newAddr in addrs)
+            return;
+        else
+            addrs[newAddr] = true;
+        const displayAddrs = Object.keys(addrs).filter(function (k) {
+            return addrs[k];
+        });
+        if (displayAddrs && displayAddrs.length == 1) {
+            resolve(NetworkRatchet.updateLocalIP(displayAddrs[0]));
+        }
+        else {
+            const multi = displayAddrs.sort().join(',');
+            logger_1.Logger.warn('Multiple addresses found, returning sorted join : %s', multi);
+            resolve(NetworkRatchet.updateLocalIP(multi));
+        }
+    }
+}
+exports.NetworkRatchet = NetworkRatchet;
+NetworkRatchet.LOCAL_IP = null;

package/dist/cjs/stream/buffer-writable.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferWritable = void 0;
+const stream_1 = require("stream");
+class BufferWritable extends stream_1.Writable {
+    constructor() {
+        super();
+        this._val = [];
+    }
+    _write(chunk, encoding, callback) {
+        if (chunk) {
+            this._val.push(chunk);
+        }
+        callback();
+    }
+    get value() {
+        return Buffer.concat(this._val);
+    }
+}
+exports.BufferWritable = BufferWritable;

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamRatchet = void 0;
+const stream_1 = require("stream");
+const error_ratchet_1 = require("../lang/error-ratchet");
+const string_ratchet_1 = require("../lang/string-ratchet");
+class StreamRatchet {
+    constructor() { }
+    static readableToBufferSync(stream) {
+        const bufs = [];
+        let next = stream.read();
+        while (next) {
+            bufs.push(next);
+            next = stream.read();
+        }
+        return Buffer.concat(bufs);
+    }
+    static async webReadableStreamToBuffer(stream) {
+        const out = [];
+        const writer = new WritableStream({
+            async write(chunk, controller) {
+                if (typeof chunk === 'string') {
+                    string_ratchet_1.StringRatchet.stringToUint8Array(chunk);
+                }
+                else {
+                    out.push(chunk);
+                }
+                return null;
+            },
+            abort(reason) {
+                error_ratchet_1.ErrorRatchet.throwFormattedErr('StringWebWritableStream failure : %s', reason);
+            },
+        }, {
+            highWaterMark: 3,
+            size: () => 1,
+        });
+        await stream.pipeTo(writer);
+        return Buffer.concat(out);
+    }
+    static async webReadableStreamToString(stream) {
+        const buf = await StreamRatchet.webReadableStreamToBuffer(stream);
+        return buf.toString();
+    }
+    static stringToReadable(input) {
+        return new stream_1.Readable({
+            read() {
+                this.push(input);
+                this.push(null);
+            },
+        });
+    }
+    static stringToWebReadableStream(input) {
+        const rval = new ReadableStream({
+            start(controller) {
+                if (input) {
+                    controller.enqueue(input);
+                }
+                controller.close();
+                return null;
+            },
+        }, {
+            highWaterMark: input ? input.length : null,
+        });
+        return rval;
+    }
+    static anyToStringReadable(input) {
+        return input === null || input === undefined
+            ? StreamRatchet.stringToReadable(null)
+            : StreamRatchet.stringToReadable(string_ratchet_1.StringRatchet.safeString(input));
+    }
+}
+exports.StreamRatchet = StreamRatchet;

package/dist/cjs/stream/string-writable.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringWritable = void 0;
+const stream_1 = require("stream");
+class StringWritable extends stream_1.Writable {
+    constructor() {
+        super();
+        this._val = '';
+    }
+    _write(chunk, encoding, callback) {
+        this._val += chunk ? chunk.toString() : '';
+        callback();
+    }
+    get value() {
+        return this._val;
+    }
+}
+exports.StringWritable = StringWritable;

package/dist/cjs/third-party/google/google-recaptcha-ratchet.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleRecaptchaRatchet = void 0;
+const tslib_1 = require("tslib");
+const logger_1 = require("../../logger/logger");
+const string_ratchet_1 = require("../../lang/string-ratchet");
+const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
+class GoogleRecaptchaRatchet {
+    static async verifyRecaptchaToken(keySecret, token, fetchFn = cross_fetch_1.default) {
+        logger_1.Logger.debug('Verifying recaptcha token : %s', token);
+        let rval = null;
+        if (!string_ratchet_1.StringRatchet.safeString(token)) {
+            logger_1.Logger.warn('Recaptcha validation error, no token passed : %s', token);
+            return rval;
+        }
+        logger_1.Logger.info('Validating Recaptcha via Google API : %s', token);
+        let url = GoogleRecaptchaRatchet.GOOGLE_VERIFY_URL;
+        url = url.split('{{KEY}}').join(keySecret);
+        url = url.split('{{TOKEN}}').join(token);
+        try {
+            const resp = await fetchFn(url);
+            const body = await resp.json();
+            rval = body && body.success;
+        }
+        catch (err) {
+            logger_1.Logger.error('Failed to read from google : %s', err);
+            rval = false;
+        }
+        return rval;
+    }
+}
+exports.GoogleRecaptchaRatchet = GoogleRecaptchaRatchet;
+GoogleRecaptchaRatchet.GOOGLE_VERIFY_URL = 'https://www.google.com/recaptcha/api/siteverify?secret={{KEY}}&response={{TOKEN}}';

package/dist/cjs/third-party/twilio/twilio-ratchet.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwilioRatchet = void 0;
+const tslib_1 = require("tslib");
+const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
+const require_ratchet_1 = require("../../lang/require-ratchet");
+const base64_ratchet_1 = require("../../lang/base64-ratchet");
+const string_ratchet_1 = require("../../lang/string-ratchet");
+const logger_1 = require("../../logger/logger");
+class TwilioRatchet {
+    constructor(accountSid, authToken, outBoundNumber) {
+        this.accountSid = accountSid;
+        this.authToken = authToken;
+        this.outBoundNumber = outBoundNumber;
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(accountSid, 'accountSid');
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(authToken, 'authToken');
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(outBoundNumber, 'outBoundNumber');
+        require_ratchet_1.RequireRatchet.true(TwilioRatchet.isValidE164Number(outBoundNumber), 'outBoundNumber invalid format');
+    }
+    static async sendMessageDirect(accountSid, authToken, outBoundNumber, recipientPhoneNumbers, message) {
+        const ratchet = new TwilioRatchet(accountSid, authToken, outBoundNumber);
+        const rval = await ratchet.sendMessage(recipientPhoneNumbers, message);
+        return rval;
+    }
+    static generateTwilioBasicAuth(sid, authToken) {
+        const authHeader = 'Basic ' + base64_ratchet_1.Base64Ratchet.generateBase64VersionOfString(sid + ':' + authToken);
+        return authHeader;
+    }
+    async sendMessage(recipientPhoneNumbers, message) {
+        const rval = [];
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(recipientPhoneNumbers, 'recipientPhoneNumbers');
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(string_ratchet_1.StringRatchet.trimToNull(message), 'message');
+        require_ratchet_1.RequireRatchet.true(recipientPhoneNumbers.length > 0, 'recipientPhoneNumbers non-empty');
+        recipientPhoneNumbers.forEach((p) => {
+            require_ratchet_1.RequireRatchet.true(TwilioRatchet.isValidE164Number(p), p + ' is not valid');
+        });
+        if (!!recipientPhoneNumbers && recipientPhoneNumbers.length > 0 && !!string_ratchet_1.StringRatchet.trimToNull(message)) {
+            logger_1.Logger.info('Sending %s to %j', message, recipientPhoneNumbers);
+            for (let i = 0; i < recipientPhoneNumbers.length; i++) {
+                const phoneNumber = recipientPhoneNumbers[i];
+                logger_1.Logger.info('To: %s', phoneNumber);
+                if (!TwilioRatchet.isValidE164Number(phoneNumber)) {
+                    throw new Error('number must be E164 format!');
+                }
+                const body = 'Body=' +
+                    encodeURIComponent(message) +
+                    '&From=' +
+                    encodeURIComponent(this.outBoundNumber) +
+                    '&To=' +
+                    encodeURIComponent(phoneNumber);
+                const post = {
+                    method: 'post',
+                    headers: {
+                        authorization: TwilioRatchet.generateTwilioBasicAuth(this.accountSid, this.authToken),
+                        'Content-Type': 'application/x-www-form-urlencoded',
+                    },
+                    body: body,
+                };
+                const res = await (0, cross_fetch_1.default)(TwilioRatchet.TWILLIO_BASE_API_URL + '/Accounts/' + this.accountSid + '/Messages.json', post);
+                const parsedResponse = await res.json();
+                logger_1.Logger.debug('TwilioRatchet: For %s got %j', phoneNumber, parsedResponse);
+                rval.push(parsedResponse);
+            }
+        }
+        else {
+            logger_1.Logger.warn('Not sending empty message / empty recipients');
+        }
+        return rval;
+    }
+    static isValidE164Number(num) {
+        return /^\+?[1-9]\d{1,14}$/.test(num);
+    }
+}
+exports.TwilioRatchet = TwilioRatchet;
+TwilioRatchet.TWILLIO_BASE_API_URL = 'https://api.twilio.com/2010-04-01';

package/dist/cjs/transform/built-in-transforms.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltInTransforms = void 0;
+const logger_1 = require("../logger/logger");
+const number_ratchet_1 = require("../lang/number-ratchet");
+const luxon_1 = require("luxon");
+class BuiltInTransforms {
+    static keysOnly(rule) {
+        return {
+            transform(value, isKey, context) {
+                return isKey ? rule.transform(value, isKey, context) : value;
+            },
+        };
+    }
+    static valuesOnly(rule) {
+        return {
+            transform(value, isKey, context) {
+                return !isKey ? rule.transform(value, isKey, context) : value;
+            },
+        };
+    }
+    static stringReplaceTransform(input, output) {
+        return {
+            transform(value, isKey, context) {
+                return value == input ? output : value;
+            },
+        };
+    }
+    static stripStringTransform(input) {
+        return {
+            transform(value, isKey, context) {
+                return value == input ? null : value;
+            },
+        };
+    }
+    static retainAll(input) {
+        return {
+            transform(value, isKey, context) {
+                return input.indexOf(value) == -1 ? null : value;
+            },
+        };
+    }
+    static removeAll(input) {
+        return {
+            transform(value, isKey, context) {
+                return input.indexOf(value) > -1 ? null : value;
+            },
+        };
+    }
+    static snakeToCamelCase() {
+        return {
+            transform(value, isKey, context) {
+                let rval = value;
+                if (typeof value == 'string') {
+                    rval = value.replace(/_([a-z0-9])/gi, function (s, group1) {
+                        return group1.toUpperCase();
+                    });
+                }
+                return rval;
+            },
+        };
+    }
+    static stringToNumber() {
+        return {
+            transform(value, isKey, context) {
+                let rval = value;
+                if (typeof value == 'string') {
+                    const num = number_ratchet_1.NumberRatchet.safeNumber(value);
+                    if (num !== null) {
+                        rval = num;
+                    }
+                }
+                return rval;
+            },
+        };
+    }
+    static camelToSnakeCase() {
+        return {
+            transform(value, isKey, context) {
+                let rval = value;
+                if (typeof value == 'string') {
+                    rval = value
+                        .replace(/\.?([A-Z]+)/g, function (x, y) {
+                        return '_' + y.toLowerCase();
+                    })
+                        .replace(/^_/, '');
+                }
+                return rval;
+            },
+        };
+    }
+    static concatenateToNewField(newFieldName, oldFieldNamesInOrder, abortIfFieldMissing = true) {
+        return {
+            transform(value, isKey, context) {
+                if (typeof value == 'object') {
+                    let rval = '';
+                    oldFieldNamesInOrder.forEach((n) => {
+                        if (rval != null) {
+                            const temp = value[n];
+                            if (temp == null && abortIfFieldMissing) {
+                                rval = null;
+                            }
+                            else {
+                                rval = temp == null ? rval : rval + String(temp);
+                            }
+                        }
+                    });
+                    if (rval != null) {
+                        value[newFieldName] = rval;
+                        oldFieldNamesInOrder.forEach((n) => delete value[n]);
+                    }
+                }
+                return value;
+            },
+        };
+    }
+    static numberToBool(fieldNames) {
+        return {
+            transform(value, isKey, context) {
+                if (typeof value == 'object') {
+                    fieldNames.forEach((n) => {
+                        const oldVal = value[n];
+                        if (typeof oldVal == 'number') {
+                            const newVal = 0 != oldVal;
+                            value[n] = newVal;
+                        }
+                    });
+                }
+                return value;
+            },
+        };
+    }
+    static boolToNumber(fieldNames) {
+        return {
+            transform(value, isKey, context) {
+                if (typeof value == 'object') {
+                    fieldNames.forEach((n) => {
+                        const oldVal = value[n];
+                        if (typeof oldVal == 'boolean') {
+                            const newVal = oldVal ? 1 : 0;
+                            value[n] = newVal;
+                        }
+                    });
+                }
+                return value;
+            },
+        };
+    }
+    static makeDuplicateField(oldName, newName) {
+        return {
+            transform(value, isKey, context) {
+                if (typeof value == 'object') {
+                    const oldVal = value[oldName];
+                    if (oldVal != null) {
+                        value[newName] = oldVal;
+                    }
+                }
+                return value;
+            },
+        };
+    }
+    static addField(name, valueToAdd) {
+        return {
+            transform(value, isKey, context) {
+                if (typeof value == 'object') {
+                    value[name] = valueToAdd;
+                }
+                return value;
+            },
+        };
+    }
+    static reformatDateFields(fieldNames, oldFormat, newFormat) {
+        return {
+            transform(value, isKey, context) {
+                if (typeof value == 'object') {
+                    fieldNames.forEach((key) => {
+                        const oldValue = value[key];
+                        if (oldValue != null) {
+                            try {
+                                const parsed = luxon_1.DateTime.fromFormat(oldValue, oldFormat);
+                                const newValue = parsed.toFormat(newFormat);
+                                value[key] = newValue;
+                            }
+                            catch (err) {
+                                logger_1.Logger.warn('Failed to reparse date %s in format %s : %s', oldValue, oldFormat, err);
+                            }
+                        }
+                    });
+                }
+                return value;
+            },
+        };
+    }
+}
+exports.BuiltInTransforms = BuiltInTransforms;

package/dist/cjs/transform/transform-rule.js

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

package/dist/cjs/tx/transaction-configuration.js

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

package/dist/cjs/tx/transaction-final-state.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionFinalState = void 0;
+var TransactionFinalState;
+(function (TransactionFinalState) {
+    TransactionFinalState["Success"] = "Success";
+    TransactionFinalState["RolledBack"] = "RolledBack";
+    TransactionFinalState["RollbackFailed"] = "RollbackFailed";
+})(TransactionFinalState = exports.TransactionFinalState || (exports.TransactionFinalState = {}));

package/dist/cjs/tx/transaction-ratchet.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionRatchet = void 0;
+const logger_1 = require("../logger/logger");
+const require_ratchet_1 = require("../lang/require-ratchet");
+const logger_level_name_1 = require("../logger/logger-level-name");
+const transaction_final_state_1 = require("./transaction-final-state");
+class TransactionRatchet {
+    static async execute(steps, initialContext, inConfiguration) {
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(steps, 'steps');
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(initialContext, 'initialContext');
+        require_ratchet_1.RequireRatchet.true(steps.length > 0, 'steps may not be empty');
+        const config = Object.assign({}, inConfiguration || {});
+        config.stepLogLevel = config.stepLogLevel || logger_level_name_1.LoggerLevelName.info;
+        const rval = {
+            finalContext: initialContext,
+            finalState: null,
+        };
+        const stepNames = steps.map((s, idx) => s.name || 'Step ' + idx);
+        logger_1.Logger.info('Beginning transaction of %d steps', steps.length);
+        let idx = 0;
+        do {
+            logger_1.Logger.logByLevel(config.stepLogLevel, 'Processing step %d of %d (%s)', idx + 1, steps.length, stepNames[idx]);
+            try {
+                await steps[idx].execute(rval.finalContext, idx);
+                idx++;
+            }
+            catch (err) {
+                logger_1.Logger.error('Failure detected on step %d : %s : %s : Rolling back', idx, stepNames[idx], err, err);
+                rval.error = err;
+                rval.errorStep = idx;
+            }
+        } while (!rval.error && idx < steps.length);
+        if (rval.error) {
+            do {
+                logger_1.Logger.logByLevel(config.stepLogLevel, 'Rolling back step %d of %d (%s)', idx + 1, steps.length, stepNames[idx]);
+                try {
+                    if (steps[idx].rollback) {
+                        await steps[idx].rollback(rval.finalContext, idx);
+                    }
+                    else {
+                        logger_1.Logger.info('Skipping - no rollback defined');
+                    }
+                }
+                catch (err) {
+                    logger_1.Logger.error('Very bad - rollback code failed on step %d : %s : Aborting in invalid state: %s', idx, stepNames[idx], err, err);
+                    rval.rollbackError = err;
+                    rval.rollbackErrorStep = idx;
+                }
+                idx--;
+            } while (idx >= 0);
+        }
+        rval.finalState = rval.rollbackError
+            ? transaction_final_state_1.TransactionFinalState.RollbackFailed
+            : rval.error
+                ? transaction_final_state_1.TransactionFinalState.RolledBack
+                : transaction_final_state_1.TransactionFinalState.Success;
+        logger_1.Logger.info('Transaction completed with status : %s', rval.finalState);
+        if ((config === null || config === void 0 ? void 0 : config.executeAfterRollback) && rval.finalState !== transaction_final_state_1.TransactionFinalState.Success) {
+            try {
+                logger_1.Logger.info('Applying executeAfterRollback');
+                await config.executeAfterRollback(rval);
+            }
+            catch (err) {
+                logger_1.Logger.error('Very bad - failure in executeAfterRollback : %s', err, err);
+            }
+        }
+        if ((config === null || config === void 0 ? void 0 : config.executeAfterRollbackFailure) && rval.finalState !== transaction_final_state_1.TransactionFinalState.Success) {
+            try {
+                logger_1.Logger.info('Applying executeAfterRollbackFailure');
+                await config.executeAfterRollbackFailure(rval);
+            }
+            catch (err) {
+                logger_1.Logger.error('Very bad - failure in executeAfterRollbackFailure : %s', err, err);
+            }
+        }
+        return rval;
+    }
+}
+exports.TransactionRatchet = TransactionRatchet;

package/dist/cjs/tx/transaction-result.js

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

package/dist/cjs/tx/transaction-step.js

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

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};