@bitblit/ratchet-common 4.0.115-alpha → 4.0.119-alpha

package/lib/lang/promise-ratchet.js

@@ -1,138 +0,0 @@
-import { Logger } from '../logger/logger.js';
-import { ArrayRatchet } from './array-ratchet.js';
-import { TimeoutToken } from './timeout-token.js';
-import { StopWatch } from './stop-watch.js';
-import { LoggerLevelName } from '../logger/logger-level-name.js';
-export class PromiseRatchet {
-    static resolveOnEvent(evtSrc, okEvtNames, errEvtNames = [], rval = null) {
-        if (!evtSrc || !okEvtNames || okEvtNames.length === 0 || !evtSrc['on']) {
-            Promise.reject('Cannot continue - missing source object or name, or the object is not an event source');
-        }
-        return new Promise((res, rej) => {
-            okEvtNames.forEach((e) => {
-                evtSrc.on(e, () => {
-                    res(rval);
-                });
-            });
-            if (!!errEvtNames) {
-                errEvtNames.forEach((e) => {
-                    evtSrc.on(e, (err) => {
-                        rej(err);
-                    });
-                });
-            }
-        });
-    }
-    static timeout(srcPromise, title, timeoutMS) {
-        return Promise.race([srcPromise, PromiseRatchet.createTimeoutPromise(title, timeoutMS)]);
-    }
-    static createTimeoutPromise(title, timeoutMS) {
-        return new Promise((resolve, reject) => {
-            const id = setTimeout(() => {
-                clearTimeout(id);
-                const rval = new TimeoutToken(title, timeoutMS);
-                resolve(rval);
-            }, timeoutMS);
-        });
-    }
-    static async wait(time) {
-        await PromiseRatchet.createTimeoutPromise('Wait ' + time, time);
-        Logger.silly('Finished wait of %d ms', time);
-    }
-    static dumpResult(result, autoDebug = false) {
-        Logger.info('Success, result was : \n\n%s\n\n', JSON.stringify(result));
-        if (autoDebug) {
-            debugger;
-        }
-        process.exit(0);
-    }
-    static dumpError(err, autoDebug = false) {
-        Logger.warn('Failure, err was : \n\n%s\n\n  --  \n\n%s\n\n', JSON.stringify(err), String(err));
-        console.trace();
-        if (autoDebug) {
-            debugger;
-        }
-        process.exit(1);
-    }
-    static logErrorAndReturnNull(err, autoDebug = false) {
-        Logger.warn('Failure, err was : \n\n%s\n\n  --  \n\n%s\n\n', JSON.stringify(err), String(err));
-        if (autoDebug) {
-            debugger;
-        }
-        return null;
-    }
-    static runPromiseAndDump(promise) {
-        promise.then(PromiseRatchet.dumpResult).catch(PromiseRatchet.dumpError);
-    }
-    static async waitFor(testFunction, expectedValue, intervalMS, maxCycles, label = 'waitFor', count = 0) {
-        if (expectedValue == null || intervalMS < 50 || maxCycles < 1 || count < 0 || typeof testFunction != 'function') {
-            Logger.warn('%s: Invalid configuration for waitFor - exiting immediately', label);
-            Logger.warn('ExpectedValue : %s ; interval: %d ; maxCycles: %d ; test : %s', expectedValue, intervalMS, maxCycles, typeof testFunction);
-            return false;
-        }
-        let curVal = null;
-        try {
-            curVal = testFunction(count);
-        }
-        catch (err) {
-            Logger.warn('%s: Caught error while waiting, giving up', label);
-            return false;
-        }
-        if (curVal === null) {
-            Logger.debug('%s:CurVal was null - aborting', label);
-            return false;
-        }
-        else if (curVal == expectedValue) {
-            Logger.debug('%s:Found expected value', label);
-            return true;
-        }
-        else if (count > maxCycles) {
-            Logger.debug('%s:Exceeded max cycles, giving up', label);
-            return false;
-        }
-        else {
-            Logger.debug('%s : value not reached yet, waiting (count = %d of %d)', label, count, maxCycles);
-            await PromiseRatchet.wait(intervalMS);
-            return PromiseRatchet.waitFor(testFunction, expectedValue, intervalMS, maxCycles, label, count + 1);
-        }
-    }
-    static async runBoundedParallel(promiseFn, params, context, maxConcurrent = 1, logLevel = LoggerLevelName.debug) {
-        const sw = new StopWatch();
-        let rval = [];
-        let remain = params;
-        Logger.logByLevel(logLevel, 'Processing %d total elements %d at a time', params.length, maxConcurrent);
-        const ctx = context || this;
-        let processed = 0;
-        const totalCount = remain.length;
-        while (remain.length > 0) {
-            const curBatch = remain.slice(0, Math.min(remain.length, maxConcurrent));
-            remain = remain.slice(curBatch.length);
-            const proms = curBatch.map((c) => promiseFn.apply(ctx, c));
-            const output = await Promise.all(proms);
-            processed += proms.length;
-            rval = rval.concat(output);
-            const pct = processed / totalCount;
-            Logger.logByLevel(logLevel, '%d elements remain : %s', remain.length, sw.dumpExpected(pct));
-        }
-        sw.log();
-        return rval;
-    }
-    static async runBoundedParallelSingleParam(promiseFn, params, context, maxConcurrent = 1, logLevel = LoggerLevelName.debug) {
-        const wrappedParams = ArrayRatchet.wrapElementsInArray(params);
-        return PromiseRatchet.runBoundedParallel(promiseFn, wrappedParams, context, maxConcurrent, logLevel);
-    }
-    static async asyncForEachSerial(array, callback) {
-        for (let index = 0; index < array.length; index++) {
-            await callback(array[index], index, array);
-        }
-    }
-    static async asyncForEachParallel(array, callback) {
-        const proms = [];
-        for (let index = 0; index < array.length; index++) {
-            proms.push(callback(array[index], index, array));
-        }
-        await Promise.all(proms);
-    }
-    constructor() {
-    }
-}

package/lib/lang/promise-ratchet.spec.js

@@ -1,74 +0,0 @@
-import { PromiseRatchet } from './promise-ratchet.js';
-import { Logger } from '../logger/logger.js';
-import { LoggerLevelName } from '../logger/logger-level-name.js';
-const fnFalse = (ignored) => {
-    return false;
-};
-const fnOn3 = (t) => {
-    Logger.info('t=%d', t);
-    return t == 3;
-};
-const waitAndPrint = async (t1, t2) => {
-    Logger.info('Running: %s', t2);
-    await PromiseRatchet.wait(t1 * 2);
-    return t1 * 2;
-};
-describe('#promiseRatchet', function () {
-    it('should timeout eventually', async () => {
-        try {
-            Logger.setLevel(LoggerLevelName.silly);
-            const result = await PromiseRatchet.waitFor(fnFalse, true, 100, 2);
-            Logger.info('Got : %s', result);
-            expect(result).toEqual(false);
-        }
-        catch (err) {
-            Logger.warn('Error: %s', err, err);
-        }
-    });
-    it('should succeed on 3rd try', async () => {
-        const promise = PromiseRatchet.waitFor(fnOn3, true, 100, 4);
-        const result = await promise;
-        expect(result).toEqual(true);
-    });
-    it('should run 10 elements, 2 at a time', async () => {
-        Logger.setLevel(LoggerLevelName.debug);
-        const elements = [
-            [100, 'Test1'],
-            [200, 'Test2'],
-            [300, 'Test3'],
-            [400, 'Test4'],
-            [500, 'Test5'],
-            [600, 'Test6'],
-            [700, 'Test7'],
-            [800, 'Test8'],
-            [900, 'Test9'],
-            [1000, 'Test10'],
-        ];
-        const results = await PromiseRatchet.runBoundedParallel(waitAndPrint, elements, this, 2);
-        Logger.info('Final results %j', results);
-        expect(results).toBeTruthy();
-        expect(results.length).toEqual(10);
-    }, 30000);
-    it('should run 10 waits, 2 at a time', async () => {
-        Logger.setLevel(LoggerLevelName.debug);
-        const elements = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000];
-        const results = await PromiseRatchet.runBoundedParallelSingleParam(PromiseRatchet.wait, elements, this, 2);
-        Logger.info('Final results %j', results);
-        expect(results).toBeTruthy();
-        expect(results.length).toEqual(10);
-    });
-    xit('should run an async function as a for/each', async () => {
-        Logger.setLevel(LoggerLevelName.debug);
-        const elements = [1001, 1002, 2000];
-        const pfn = async (v) => {
-            Logger.info('Waiting %s', v);
-            await PromiseRatchet.wait(v);
-            Logger.info('Finished %s', v);
-        };
-        Logger.info('Serial test');
-        await PromiseRatchet.asyncForEachSerial(elements, pfn);
-        Logger.info('Parallel test');
-        await PromiseRatchet.asyncForEachParallel(elements, pfn);
-        Logger.info('Done');
-    });
-});

package/lib/lang/require-ratchet.js

@@ -1,56 +0,0 @@
-import { ErrorRatchet } from './error-ratchet.js';
-export class RequireRatchet {
-    static isNullOrUndefined(ob) {
-        return ob === null || ob === undefined;
-    }
-    static notNullOrUndefined(ob, name = 'object') {
-        if (RequireRatchet.isNullOrUndefined(ob)) {
-            throw new Error(name + ' may not be null or undefined');
-        }
-    }
-    static notNullUndefinedOrOnlyWhitespaceString(ob, name = 'string') {
-        if (RequireRatchet.isNullOrUndefined(ob) || ob.trim() === '') {
-            throw new Error(name + ' may not be null or undefined or only whitespace string');
-        }
-    }
-    static notNullUndefinedOrEmptyArray(ob, name = 'string') {
-        if (RequireRatchet.isNullOrUndefined(ob) || ob.length === 0) {
-            throw new Error(name + ' may not be null or undefined or an empty array');
-        }
-    }
-    static equal(ob1, ob2, message = 'Values must be equal') {
-        if (ob1 !== ob2) {
-            throw new Error(message);
-        }
-    }
-    static true(ob, message = 'Value must be true') {
-        RequireRatchet.equal(ob, true, message);
-    }
-    static noNullOrUndefinedValuesInArray(arr, expectedLength = null, customMsg = null) {
-        RequireRatchet.notNullOrUndefined(arr, 'Source array may not be null');
-        if (expectedLength !== null && arr.length !== expectedLength) {
-            ErrorRatchet.throwFormattedErr('Expected array of length %d but was %d %s', expectedLength, arr.length, customMsg);
-        }
-        for (let i = 0; i < arr.length; i++) {
-            if (RequireRatchet.isNullOrUndefined(arr[i])) {
-                ErrorRatchet.throwFormattedErr('Array index %d was null or undefined %s', i, customMsg);
-            }
-        }
-    }
-    static noNullOrUndefinedValuesInRestArgs(expectedLength, ...restArgs) {
-        RequireRatchet.notNullOrUndefined(restArgs, 'Source array may not be null');
-        if (expectedLength !== null && restArgs.length !== expectedLength) {
-            ErrorRatchet.throwFormattedErr('Expected array of length %d but was %d', expectedLength, restArgs.length);
-        }
-        for (let i = 0; i < restArgs.length; i++) {
-            if (RequireRatchet.isNullOrUndefined(restArgs[i])) {
-                ErrorRatchet.throwFormattedErr('Array index %d was null or undefined', i);
-            }
-        }
-    }
-    static constructorArgumentsMatchLengthAndAreNonNull() {
-        const args = Array.from(arguments);
-        const len = this.constructor.length;
-        return RequireRatchet.noNullOrUndefinedValuesInArray(args, len);
-    }
-}

package/lib/lang/require-ratchet.spec.js

@@ -1,80 +0,0 @@
-import { RequireRatchet } from './require-ratchet.js';
-import { fail } from 'assert';
-import { Logger } from '../logger/logger.js';
-describe('#standardCases', function () {
-    it('should throw exception on null value', function () {
-        try {
-            RequireRatchet.notNullOrUndefined(null, 'test1');
-            fail('Should have thrown exception');
-        }
-        catch (err) {
-            Logger.debug('Correctly threw exception : %s', err);
-        }
-        try {
-            RequireRatchet.notNullOrUndefined(undefined, 'test2');
-            fail('Should have thrown exception');
-        }
-        catch (err) {
-            Logger.debug('Correctly threw exception : %s', err);
-        }
-    });
-    it('should throw exception on whitespace value', function () {
-        try {
-            RequireRatchet.notNullUndefinedOrOnlyWhitespaceString('', 'test1');
-            fail('Should have thrown exception');
-        }
-        catch (err) {
-            Logger.debug('Correctly threw exception : %s', err);
-        }
-        try {
-            RequireRatchet.notNullUndefinedOrOnlyWhitespaceString('    ', 'test2');
-            fail('Should have thrown exception');
-        }
-        catch (err) {
-            Logger.debug('Correctly threw exception : %s', err);
-        }
-    });
-});
-describe('#noNullOrUndefinedValuesInArray', function () {
-    it('should throw exception on null value', function () {
-        const arr = [1, null, 'a'];
-        try {
-            RequireRatchet.noNullOrUndefinedValuesInArray(arr);
-            fail('Should have thrown exception');
-        }
-        catch (err) {
-            Logger.debug('Correctly threw exception : %s', err);
-        }
-    });
-    it('throw exception on bad length', function () {
-        const arr = [1, 2, 'a'];
-        try {
-            RequireRatchet.noNullOrUndefinedValuesInArray(arr, 4);
-            fail('Should have thrown exception');
-        }
-        catch (err) {
-            Logger.debug('Correctly threw exception : %s', err);
-        }
-    });
-    it('should not throw exception on good values', function () {
-        const arr = [1, 2, 'a'];
-        RequireRatchet.noNullOrUndefinedValuesInArray(arr, 3);
-    });
-    it('should not throw exception on good constructor values', function () {
-        const test = new ConstructorTester('a', 'b');
-    });
-    it('throw exception on null constructor param', function () {
-        try {
-            const test = new ConstructorTester('a', null);
-            fail('Should have thrown exception');
-        }
-        catch (err) {
-            Logger.debug('Correctly threw exception : %s', err);
-        }
-    });
-});
-export class ConstructorTester {
-    constructor(testVal1, testVal2) {
-        Logger.info('Args : %j', this.constructor);
-    }
-}

package/lib/lang/stop-watch.js

@@ -1,114 +0,0 @@
-import { DurationRatchet } from './duration-ratchet.js';
-import { StringRatchet } from './string-ratchet.js';
-import { RequireRatchet } from './require-ratchet.js';
-import { LoggerLevelName } from '../logger/logger-level-name.js';
-import { Logger } from '../logger/logger.js';
-export class StopWatch {
-    label;
-    starts = new Map();
-    ends = new Map();
-    createTime = Date.now();
-    constructor(label = StringRatchet.createRandomHexString(4)) {
-        this.label = label;
-    }
-    start(name) {
-        RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
-        const now = Date.now();
-        this.starts.set(StringRatchet.trimToNull(name), now);
-        return now;
-    }
-    stop(name) {
-        RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
-        const now = Date.now();
-        this.ends.set(StringRatchet.trimToNull(name), now);
-        return now;
-    }
-    reset(name) {
-        RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
-        this.starts.delete(StringRatchet.trimToNull(name));
-        this.ends.delete(StringRatchet.trimToNull(name));
-    }
-    hasTimer(name) {
-        RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
-        return this.starts.has(name);
-    }
-    log(name, shortForm, logLevel = LoggerLevelName.info) {
-        Logger.logByLevel(logLevel, this.dump(name, shortForm));
-    }
-    logExpected(pctComplete, name, shortForm, logLevel = LoggerLevelName.info) {
-        Logger.logByLevel(logLevel, this.dumpExpected(pctComplete, name, shortForm));
-    }
-    dump(name, shortForm) {
-        let rval = this.label + ' ';
-        const cleanName = StringRatchet.trimToNull(name);
-        if (cleanName && !this.hasTimer(cleanName)) {
-            rval += 'No such timer : ' + cleanName;
-        }
-        else {
-            const start = name ? this.starts.get(cleanName) : this.createTime;
-            const end = name ? this.ends.get(cleanName) : Date.now();
-            rval += (cleanName || 'Default') + ' ';
-            if (!!start && !!end) {
-                rval += 'completed in ' + DurationRatchet.formatMsDuration(end - start, !shortForm);
-            }
-            else if (!!start) {
-                rval += 'running for ' + DurationRatchet.formatMsDuration(Date.now() - start, !shortForm);
-            }
-        }
-        return rval;
-    }
-    dumpExpected(pctComplete, name, shortForm) {
-        let rval = this.label + ' ';
-        const cleanName = StringRatchet.trimToNull(name);
-        if (cleanName && !this.hasTimer(cleanName)) {
-            rval += 'No such timer : ' + cleanName;
-        }
-        else {
-            if (!pctComplete || pctComplete <= 0) {
-                rval += 'Cannot generate output for 0 percent complete';
-            }
-            else if (pctComplete > 1) {
-                rval += 'Cannot generate output for percent > 1';
-            }
-            else {
-                rval += (cleanName || 'Default') + ' ';
-                const start = name ? this.starts.get(cleanName) : this.createTime;
-                const end = name ? this.ends.get(cleanName) : Date.now();
-                if (!!start && !!end) {
-                    rval += 'completed in ' + DurationRatchet.formatMsDuration(end - start, !shortForm);
-                }
-                else if (!!start) {
-                    const now = Date.now();
-                    const elapsedMS = now - start;
-                    const expectedTotalMS = elapsedMS / pctComplete;
-                    const remainMS = expectedTotalMS - elapsedMS;
-                    rval +=
-                        'running for ' +
-                            DurationRatchet.formatMsDuration(elapsedMS, !shortForm) +
-                            ' approx ' +
-                            DurationRatchet.formatMsDuration(remainMS, !shortForm) +
-                            ' remaining';
-                }
-            }
-        }
-        return rval;
-    }
-    elapsedMS(name) {
-        let rval = null;
-        const cleanName = StringRatchet.trimToNull(name);
-        if (cleanName && !this.hasTimer(cleanName)) {
-            rval = null;
-        }
-        else {
-            const start = name ? this.starts.get(cleanName) : this.createTime;
-            const end = name ? this.ends.get(cleanName) : Date.now();
-            if (!!start && !!end) {
-                rval = end - start;
-            }
-            else if (!!start) {
-                rval = Date.now() - start;
-            }
-        }
-        return rval;
-    }
-}

package/lib/lang/string-ratchet.js

@@ -1,201 +0,0 @@
-import { RequireRatchet } from './require-ratchet.js';
-export class StringRatchet {
-    static RFC_3986_RESERVED = ['!', '*', "'", '(', ')', ';', ':', '@', '&', '=', '+', '$', ',', '/', '?', '#', '[', ']', '%'];
-    static stringToUint8Array(val) {
-        return val ? new TextEncoder().encode(val) : null;
-    }
-    static uint8ArrayToString(val) {
-        return val ? new TextDecoder().decode(val) : null;
-    }
-    static attemptJsonParse(val) {
-        let rval = null;
-        if (StringRatchet.trimToNull(val)) {
-            try {
-                rval = JSON.parse(val);
-            }
-            catch (err) {
-                rval = null;
-            }
-        }
-        return rval;
-    }
-    static canParseAsJson(val) {
-        return !!StringRatchet.attemptJsonParse(val);
-    }
-    static allUnique(input) {
-        let rval = true;
-        if (input) {
-            const check = new Set();
-            for (let i = 0; i < input.length && rval; i++) {
-                const test = input.charAt(i);
-                rval = !check.has(test);
-                check.add(test);
-            }
-        }
-        return rval;
-    }
-    static allPermutationsOfLength(len, alphabet) {
-        const rval = [];
-        if (len > 0 && alphabet && alphabet.length > 0) {
-            RequireRatchet.true(StringRatchet.allUnique(alphabet), 'Alphabet must be unique');
-            const step = len === 1 ? [''] : StringRatchet.allPermutationsOfLength(len - 1, alphabet);
-            for (let i = 0; i < alphabet.length; i++) {
-                step.forEach((s) => rval.push(alphabet.charAt(i) + s));
-            }
-        }
-        return rval;
-    }
-    static createType4Guid() {
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-            const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
-            return v.toString(16);
-        });
-    }
-    static createRandomHexString(len = 10) {
-        let r = '';
-        for (let i = 0; i < len; i++) {
-            r += Math.floor(Math.random() * 16).toString(16);
-        }
-        return r;
-    }
-    static canonicalize(value) {
-        let rval = value ? value.toLowerCase() : '';
-        rval = rval.replace(' ', '-');
-        StringRatchet.RFC_3986_RESERVED.forEach((s) => {
-            rval = rval.replace(s, '');
-        });
-        return rval;
-    }
-    static formatBytes(bytes, decimals = 2) {
-        if (bytes == 0)
-            return '0 Bytes';
-        const k = 1024, dm = decimals || 2, sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], i = Math.floor(Math.log(bytes) / Math.log(k));
-        return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
-    }
-    static safeString(input) {
-        let rval = null;
-        if (input != null) {
-            const type = typeof input;
-            if (type == 'string') {
-                rval = input;
-            }
-            else {
-                rval = String(input);
-            }
-        }
-        return rval;
-    }
-    static stringContainsOnlyNumbers(input) {
-        const rval = /^[0-9]+$/.test(input);
-        return rval;
-    }
-    static stringContainsOnlyAlphanumeric(input) {
-        const rval = /^[0-9a-zA-Z]+$/.test(input);
-        return rval;
-    }
-    static stringContainsOnlyHex(input) {
-        const rval = /^[0-9a-fA-F]+$/.test(input);
-        return rval;
-    }
-    static stringContainsOnly(inVal, validCharsIn) {
-        const input = !inVal ? '' : inVal;
-        const validChars = !validCharsIn ? '' : validCharsIn;
-        let rval = true;
-        for (let i = 0; i < input.length && rval; i++) {
-            rval = validChars.indexOf(input.charAt(i)) >= 0;
-        }
-        return rval;
-    }
-    static obscure(input, prefixLength = 2, suffixLength = 2) {
-        if (!input) {
-            return input;
-        }
-        const len = input.length;
-        let pl = prefixLength;
-        let sl = suffixLength;
-        while (len > 0 && len < pl + sl + 1) {
-            pl = Math.max(0, pl - 1);
-            sl = Math.max(0, sl - 1);
-        }
-        const rem = len - (pl + sl);
-        let rval = '';
-        rval += input.substring(0, pl);
-        for (let i = 0; i < rem; i++) {
-            rval += '*';
-        }
-        rval += input.substring(len - sl);
-        return rval;
-    }
-    static leadingZeros(inVal, size) {
-        const pad = '00000000000000000000000000000000000000000000000000';
-        let negative = false;
-        let sVal = String(inVal);
-        if (sVal.startsWith('-')) {
-            negative = true;
-            sVal = sVal.substring(1);
-        }
-        if (size > pad.length) {
-            throw new Error('Cannot format number that large');
-        }
-        let rval = (pad + sVal).slice(-1 * size);
-        if (negative) {
-            rval = '-' + rval;
-        }
-        return rval;
-    }
-    static trimToEmpty(input) {
-        const t = input ? StringRatchet.safeString(input) : '';
-        return t.trim();
-    }
-    static trimToNull(input) {
-        const x = StringRatchet.trimToEmpty(input);
-        return x.length > 0 ? x : null;
-    }
-    static trimAllStringPropertiesToNullInPlace(input) {
-        return StringRatchet.trimAllStringPropertiesInPlace(input, false);
-    }
-    static trimAllStringPropertiesToEmptyInPlace(input) {
-        return StringRatchet.trimAllStringPropertiesInPlace(input, true);
-    }
-    static trimAllStringPropertiesInPlace(input, toEmpty) {
-        const dealKeys = Object.keys(input);
-        dealKeys.forEach((key) => {
-            const val = input[key];
-            if (val != null && typeof val === 'string') {
-                input[key] = toEmpty ? StringRatchet.trimToEmpty(input[key]) : StringRatchet.trimToNull(input[key]);
-            }
-        });
-        return input;
-    }
-    static stripNonNumeric(input) {
-        let rval = input;
-        if (input != null && !StringRatchet.stringContainsOnlyNumbers(input)) {
-            rval = '';
-            for (let i = 0; i < input.length; i++) {
-                const c = input.charAt(i);
-                if (StringRatchet.stringContainsOnlyNumbers(c) || (i === 0 && c === '-')) {
-                    rval += c;
-                }
-            }
-        }
-        return rval;
-    }
-    static csvSafe(input) {
-        let rval = StringRatchet.trimToEmpty(StringRatchet.safeString(input));
-        rval.split('"').join('\\"');
-        if (rval.indexOf(',') !== -1 || rval.indexOf('"') !== -1 || rval.indexOf("'") !== -1) {
-            rval = '"' + rval + '"';
-        }
-        return rval;
-    }
-    static stripNonAscii(value) {
-        const reduced = [...value].reduce((previousValue, currentValue) => {
-            const charCode = currentValue.charCodeAt(0);
-            if (charCode > 127) {
-                return previousValue;
-            }
-            return previousValue + currentValue;
-        });
-        return reduced;
-    }
-}