@bitblit/ratchet-common 4.0.80-alpha

package/dist/es/logger/logger-ring-buffer.js

@@ -0,0 +1,72 @@
+import { Logger } from './logger';
+import { LoggerLevelName } from './logger-level-name';
+export class LoggerRingBuffer {
+    constructor(size) {
+        this._lastLogMessage = { messageSource: 'No message yet', timestamp: new Date().getTime(), lvl: LoggerLevelName.info };
+        this._buffer = [];
+        this._bufferIdx = 0;
+        this._lastSnapshotIdx = 0;
+        if (!size) {
+            throw new Error('Cannot create ring buffer of size 0');
+        }
+        this._bufferSize = size;
+    }
+    get currentIndex() {
+        return this._bufferIdx;
+    }
+    get lastSnapshotIdx() {
+        return this._lastSnapshotIdx;
+    }
+    set bufferSize(newSize) {
+        if (!newSize) {
+            throw new Error('Cannot create ring buffer of size 0');
+        }
+        this._bufferSize = newSize;
+        this.clearRingBuffer();
+    }
+    getMessages(inStartFrom = null, clear = false, reverseSort = false) {
+        let rval = null;
+        if (this._bufferIdx < this._bufferSize) {
+            const start = inStartFrom == null ? 0 : inStartFrom;
+            rval = this._buffer.slice(start, this._bufferIdx);
+        }
+        else {
+            rval = [];
+            const firstIdx = this._bufferIdx - this._bufferSize;
+            const startFrom = inStartFrom ? Math.max(inStartFrom, firstIdx) : firstIdx;
+            for (let i = startFrom; i < this._bufferIdx; i++) {
+                rval.push(this._buffer[i % this._bufferSize]);
+            }
+        }
+        if (clear) {
+            this.clearRingBuffer();
+        }
+        if (reverseSort) {
+            rval = rval.reverse();
+        }
+        return rval;
+    }
+    takeSnapshot() {
+        const trailingEdge = Math.max(0, this._bufferIdx - this._bufferSize);
+        const rval = {
+            messages: Logger.getMessages(this._lastSnapshotIdx),
+            logMessagesTruncated: Math.max(0, trailingEdge - this._lastSnapshotIdx),
+        };
+        this._lastSnapshotIdx = this._bufferIdx;
+        return rval;
+    }
+    getLastLogMessage() {
+        return Object.assign({}, this._lastLogMessage);
+    }
+    clearRingBuffer() {
+        this._buffer = [];
+        this._bufferIdx = 0;
+        this._lastSnapshotIdx = 0;
+        Logger.info('Cleared ring buffer (size is now %d)', this._bufferSize);
+    }
+    addToRingBuffer(newMsg) {
+        this._lastLogMessage = newMsg;
+        this._buffer[this._bufferIdx % this._bufferSize] = newMsg;
+        this._bufferIdx++;
+    }
+}

package/dist/es/logger/logger-util.js

@@ -0,0 +1,44 @@
+import { LoggerLevelName } from './logger-level-name';
+import { LoggerOutputFunction } from './logger-output-function';
+export class LoggerUtil {
+    static handlerFunctionMap(outputFn = LoggerOutputFunction.Console) {
+        const output = new Map();
+        if (outputFn === LoggerOutputFunction.StdOut) {
+            if (!process?.stdout?.write) {
+                throw new Error('Cannot use standard out - process.stdout.write not found');
+            }
+            const myStdOut = (chunk, cb) => process.stdout.write(chunk, 'utf-8', cb);
+            output.set(LoggerLevelName.error, myStdOut);
+            output.set(LoggerLevelName.warn, myStdOut);
+            output.set(LoggerLevelName.info, myStdOut);
+            output.set(LoggerLevelName.verbose, myStdOut);
+            output.set(LoggerLevelName.debug, myStdOut);
+            output.set(LoggerLevelName.silly, myStdOut);
+        }
+        else {
+            output.set(LoggerLevelName.error, console.error);
+            output.set(LoggerLevelName.warn, console.warn);
+            output.set(LoggerLevelName.info, console.info);
+            output.set(LoggerLevelName.verbose, outputFn === LoggerOutputFunction.ConsoleNoDebug ? console.log : console.debug);
+            output.set(LoggerLevelName.debug, outputFn === LoggerOutputFunction.ConsoleNoDebug ? console.log : console.debug);
+            output.set(LoggerLevelName.silly, outputFn === LoggerOutputFunction.ConsoleNoDebug ? console.log : console.debug);
+        }
+        return output;
+    }
+    static defaultHandlerFunction() {
+        return console.info;
+    }
+    static levelIsEnabled(targetLevel, currentEnabled) {
+        const idxTarget = LoggerUtil.LOG_LEVELS_IN_ORDER.indexOf(targetLevel);
+        const lvl = LoggerUtil.LOG_LEVELS_IN_ORDER.indexOf(currentEnabled);
+        return idxTarget > -1 && lvl > -1 && lvl >= idxTarget;
+    }
+}
+LoggerUtil.LOG_LEVELS_IN_ORDER = [
+    LoggerLevelName.error,
+    LoggerLevelName.warn,
+    LoggerLevelName.info,
+    LoggerLevelName.verbose,
+    LoggerLevelName.debug,
+    LoggerLevelName.silly,
+];

package/dist/es/logger/logger.js

@@ -0,0 +1,134 @@
+import { LoggerInstance } from './logger-instance';
+import { LogMessageFormatType } from './log-message-format-type';
+import { LoggerLevelName } from './logger-level-name';
+import { LoggerOutputFunction } from './logger-output-function';
+export class Logger {
+    static applyDefaultsToOptions(input) {
+        const rval = input || {};
+        rval.initialLevel = rval.initialLevel ?? Logger.DEFAULT_OPTIONS.initialLevel;
+        rval.formatType = rval.formatType ?? Logger.DEFAULT_OPTIONS.formatType;
+        rval.trace = rval.trace ?? Logger.DEFAULT_OPTIONS.trace;
+        rval.globalVars = rval.globalVars ?? Logger.DEFAULT_OPTIONS.globalVars;
+        rval.outputFunction = rval.outputFunction ?? Logger.DEFAULT_OPTIONS.outputFunction;
+        rval.ringBufferSize = rval.ringBufferSize ?? Logger.DEFAULT_OPTIONS.ringBufferSize;
+        return rval;
+    }
+    static changeDefaultOptions(input, retroactive) {
+        if (!input || !input.initialLevel || !input.formatType) {
+            throw new Error('Default options must be non-null, and provide initial level and format type');
+        }
+        Logger.DEFAULT_OPTIONS = Object.assign({}, input);
+        if (retroactive) {
+            Array.from(Logger.LOGGER_INSTANCES.values()).forEach((li) => (li.options = input));
+        }
+    }
+    static getLogger(loggerName = 'default', inOptions) {
+        let inst = Logger.LOGGER_INSTANCES.get(loggerName);
+        if (!inst) {
+            const options = Logger.applyDefaultsToOptions(inOptions);
+            inst = new LoggerInstance(loggerName, options);
+            Logger.LOGGER_INSTANCES.set(loggerName, inst);
+        }
+        return inst;
+    }
+    static recordMessageBuilder(msgBuild) {
+        return Logger.getLogger().recordMessageBuilder(msgBuild);
+    }
+    static recordMessage(msg) {
+        return Logger.getLogger().recordMessage(msg);
+    }
+    static formatMessages(msgs) {
+        return Logger.getLogger().formatMessages(msgs);
+    }
+    static updateTracePrefix(newValue) {
+        return Logger.getLogger().updateTracePrefix(newValue);
+    }
+    static changeRingBufferSize(newValue) {
+        return Logger.getLogger().changeRingBufferSize(newValue);
+    }
+    static getRingBuffer() {
+        return Logger.getLogger().ringBuffer;
+    }
+    static dumpConfigurationIntoLog() {
+        return Logger.getLogger().dumpConfigurationIntoLog();
+    }
+    static dumpOptionsIntoLog() {
+        return Logger.getLogger().dumpOptionsIntoLog();
+    }
+    static getLevel() {
+        return Logger.getLogger().level;
+    }
+    static setLevel(newLevel) {
+        Logger.getLogger().level = newLevel;
+    }
+    static getOptions() {
+        return Logger.getLogger().options;
+    }
+    static getMessages(inStartFrom = null, clear = false, reverseSort = false) {
+        const buf = Logger.getLogger().ringBuffer;
+        return buf ? buf.getMessages(inStartFrom, clear, reverseSort) : null;
+    }
+    static consoleLogPassThru(level, ...input) {
+        return Logger.getLogger().consoleLogPassThru(level, ...input);
+    }
+    static error(format, ...input) {
+        return Logger.getLogger().error(format, ...input);
+    }
+    static errorP(...input) {
+        return Logger.getLogger().errorP(...input);
+    }
+    static warn(format, ...input) {
+        return Logger.getLogger().warn(format, ...input);
+    }
+    static warnP(...input) {
+        return Logger.getLogger().warnP(...input);
+    }
+    static info(format, ...input) {
+        return Logger.getLogger().info(format, ...input);
+    }
+    static infoP(...input) {
+        return Logger.getLogger().infoP(...input);
+    }
+    static verbose(format, ...input) {
+        return Logger.getLogger().verbose(format, ...input);
+    }
+    static verboseP(...input) {
+        return Logger.getLogger().verboseP(...input);
+    }
+    static debug(format, ...input) {
+        return Logger.getLogger().debug(format, ...input);
+    }
+    static debugP(...input) {
+        return Logger.getLogger().debugP(...input);
+    }
+    static silly(format, ...input) {
+        return Logger.getLogger().silly(format, ...input);
+    }
+    static sillyP(...input) {
+        return Logger.getLogger().sillyP(...input);
+    }
+    static takeSnapshot() {
+        const buf = Logger.getLogger().ringBuffer;
+        return buf ? buf.takeSnapshot() : null;
+    }
+    static logByLevel(level, format, ...input) {
+        return Logger.getLogger().logByLevel(level, format, ...input);
+    }
+    static importMessages(msgs, prefixIn = '', addTimestamp = true) {
+        return Logger.getLogger().importMessages(msgs, prefixIn, addTimestamp);
+    }
+    static getLastLogMessage() {
+        const buf = Logger.getLogger().ringBuffer;
+        return buf ? buf.getLastLogMessage() : null;
+    }
+}
+Logger.LOGGER_INSTANCES = new Map();
+Logger.DEFAULT_OPTIONS = {
+    initialLevel: LoggerLevelName.info,
+    formatType: LogMessageFormatType.ClassicSingleLine,
+    trace: null,
+    globalVars: {},
+    outputFunction: LoggerOutputFunction.Console,
+    ringBufferSize: 0,
+    preProcessors: [],
+};

package/dist/es/logger/none-log-message-formatter.js

@@ -0,0 +1,5 @@
+export class NoneLogMessageFormatter {
+    formatMessage(msg, meta) {
+        return null;
+    }
+}

package/dist/es/logger/structured-json-log-message-formatter.js

@@ -0,0 +1,19 @@
+import util from 'util';
+export class StructuredJsonLogMessageFormatter {
+    formatMessage(msg, meta) {
+        let rval = null;
+        if (msg) {
+            const tmp = Object.assign({}, meta.options.globalVars || {}, msg.params || {});
+            tmp['msg'] = util.format(msg.messageSource, ...msg.subsVars);
+            tmp['utcDateTime'] = new Date(msg.timestamp).toISOString();
+            tmp['logLevel'] = msg.lvl;
+            if (meta.options.trace) {
+                tmp['trace'] = meta.options.trace;
+            }
+            tmp['logName'] = meta.loggerInstanceName;
+            tmp['logId'] = meta.loggerInstanceId;
+            rval = JSON.stringify(tmp) + '\n';
+        }
+        return rval;
+    }
+}

package/dist/es/network/browser-local-ip-provider.js

@@ -0,0 +1,21 @@
+import { NetworkRatchet } from './network-ratchet';
+import { Logger } from '../logger/logger';
+export class BrowserLocalIpProvider {
+    constructor() {
+        this.currentIp = 'UNSET';
+        NetworkRatchet.findLocalIp(false)
+            .then((result) => {
+            Logger.info('Setting local IP to %s', result);
+            this.currentIp = result;
+        })
+            .catch((err) => {
+            Logger.warn('Unable to set current IP - leaving as UNSET : %s', err);
+        });
+    }
+    ready() {
+        return this.currentIp !== 'UNSET';
+    }
+    currentLocalIpAddress() {
+        return this.currentIp;
+    }
+}

package/dist/es/network/fixed-local-ip-provider.js

@@ -0,0 +1,8 @@
+export class FixedLocalIpProvider {
+    constructor(fixed) {
+        this.fixed = fixed;
+    }
+    currentLocalIpAddress() {
+        return this.fixed;
+    }
+}

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

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

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

@@ -0,0 +1,102 @@
+import { Logger } from '../logger/logger';
+export class NetworkRatchet {
+    static findLocalIp(useCache = true) {
+        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.warn('Offer failed : %s', e);
+                                resolve(NetworkRatchet.updateLocalIP('FIND_UNSUPPORTED'));
+                            });
+                        }
+                        else {
+                            Logger.warn('IP Address find not supported on this device');
+                            resolve(NetworkRatchet.updateLocalIP('FIND_UNSUPPORTED'));
+                        }
+                    }
+                    catch (err) {
+                        Logger.warn('Error finding local ip address : %s', err);
+                        resolve(NetworkRatchet.updateLocalIP('ERROR'));
+                    }
+                });
+            }
+            else {
+                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.warn('Multiple addresses found, returning sorted join : %s', multi);
+            resolve(NetworkRatchet.updateLocalIP(multi));
+        }
+    }
+}
+NetworkRatchet.LOCAL_IP = null;

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

@@ -0,0 +1,16 @@
+import { Writable } from 'stream';
+export class BufferWritable extends Writable {
+    constructor() {
+        super();
+        this._val = [];
+    }
+    _write(chunk, encoding, callback) {
+        if (chunk) {
+            this._val.push(chunk);
+        }
+        callback();
+    }
+    get value() {
+        return Buffer.concat(this._val);
+    }
+}

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

@@ -0,0 +1,68 @@
+import { Readable } from 'stream';
+import { ErrorRatchet } from '../lang/error-ratchet';
+import { StringRatchet } from '../lang/string-ratchet';
+export 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') {
+                    StringRatchet.stringToUint8Array(chunk);
+                }
+                else {
+                    out.push(chunk);
+                }
+                return null;
+            },
+            abort(reason) {
+                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 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(StringRatchet.safeString(input));
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Writable } from 'stream';
+export class StringWritable extends Writable {
+    constructor() {
+        super();
+        this._val = '';
+    }
+    _write(chunk, encoding, callback) {
+        this._val += chunk ? chunk.toString() : '';
+        callback();
+    }
+    get value() {
+        return this._val;
+    }
+}

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

@@ -0,0 +1,28 @@
+import { Logger } from '../../logger/logger';
+import { StringRatchet } from '../../lang/string-ratchet';
+import fetch from 'cross-fetch';
+export class GoogleRecaptchaRatchet {
+    static async verifyRecaptchaToken(keySecret, token, fetchFn = fetch) {
+        Logger.debug('Verifying recaptcha token : %s', token);
+        let rval = null;
+        if (!StringRatchet.safeString(token)) {
+            Logger.warn('Recaptcha validation error, no token passed : %s', token);
+            return rval;
+        }
+        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.error('Failed to read from google : %s', err);
+            rval = false;
+        }
+        return rval;
+    }
+}
+GoogleRecaptchaRatchet.GOOGLE_VERIFY_URL = 'https://www.google.com/recaptcha/api/siteverify?secret={{KEY}}&response={{TOKEN}}';

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

@@ -0,0 +1,70 @@
+import fetch from 'cross-fetch';
+import { RequireRatchet } from '../../lang/require-ratchet';
+import { Base64Ratchet } from '../../lang/base64-ratchet';
+import { StringRatchet } from '../../lang/string-ratchet';
+import { Logger } from '../../logger/logger';
+export class TwilioRatchet {
+    constructor(accountSid, authToken, outBoundNumber) {
+        this.accountSid = accountSid;
+        this.authToken = authToken;
+        this.outBoundNumber = outBoundNumber;
+        RequireRatchet.notNullOrUndefined(accountSid, 'accountSid');
+        RequireRatchet.notNullOrUndefined(authToken, 'authToken');
+        RequireRatchet.notNullOrUndefined(outBoundNumber, 'outBoundNumber');
+        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 ' + Base64Ratchet.generateBase64VersionOfString(sid + ':' + authToken);
+        return authHeader;
+    }
+    async sendMessage(recipientPhoneNumbers, message) {
+        const rval = [];
+        RequireRatchet.notNullOrUndefined(recipientPhoneNumbers, 'recipientPhoneNumbers');
+        RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(message), 'message');
+        RequireRatchet.true(recipientPhoneNumbers.length > 0, 'recipientPhoneNumbers non-empty');
+        recipientPhoneNumbers.forEach((p) => {
+            RequireRatchet.true(TwilioRatchet.isValidE164Number(p), p + ' is not valid');
+        });
+        if (!!recipientPhoneNumbers && recipientPhoneNumbers.length > 0 && !!StringRatchet.trimToNull(message)) {
+            Logger.info('Sending %s to %j', message, recipientPhoneNumbers);
+            for (let i = 0; i < recipientPhoneNumbers.length; i++) {
+                const phoneNumber = recipientPhoneNumbers[i];
+                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 fetch(TwilioRatchet.TWILLIO_BASE_API_URL + '/Accounts/' + this.accountSid + '/Messages.json', post);
+                const parsedResponse = await res.json();
+                Logger.debug('TwilioRatchet: For %s got %j', phoneNumber, parsedResponse);
+                rval.push(parsedResponse);
+            }
+        }
+        else {
+            Logger.warn('Not sending empty message / empty recipients');
+        }
+        return rval;
+    }
+    static isValidE164Number(num) {
+        return /^\+?[1-9]\d{1,14}$/.test(num);
+    }
+}
+TwilioRatchet.TWILLIO_BASE_API_URL = 'https://api.twilio.com/2010-04-01';