@bitblit/ratchet-common 4.0.80-alpha

package/dist/es/lang/string-ratchet.js

@@ -0,0 +1,191 @@
+import { RequireRatchet } from './require-ratchet';
+export class StringRatchet {
+    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;
+    }
+}
+StringRatchet.RFC_3986_RESERVED = ['!', '*', "'", '(', ')', ';', ':', '@', '&', '=', '+', '$', ',', '/', '?', '#', '[', ']', '%'];

package/dist/es/lang/time-zone-ratchet.js

@@ -0,0 +1,76 @@
+import { DateTime } from 'luxon';
+export class TimeZoneRatchet {
+    constructor(timezone) {
+        if (!timezone) {
+            throw 'Timezone cannot be null';
+        }
+        this.timezone = timezone;
+    }
+    currentHour() {
+        const rval = DateTime.local().setZone(this.timezone).hour;
+        return rval;
+    }
+    toEpochSeconds(dt) {
+        return Math.round(dt.toMillis() / 1000);
+    }
+    startOfTodayEpochSeconds() {
+        const startOfToday = this.toEpochSeconds(DateTime.local().setZone(this.timezone).set({ hour: 0, minute: 0, second: 0, millisecond: 0 }));
+        return startOfToday;
+    }
+    startOfMatchingDayEpochSeconds(inputTS) {
+        const startOfToday = this.toEpochSeconds(DateTime.fromMillis(inputTS).set({ hour: 0, minute: 0, second: 0, millisecond: 0 }));
+        return startOfToday;
+    }
+    startOfMatchingDayEpochMS(inputTS) {
+        return this.startOfMatchingDayEpochSeconds(inputTS) * 1000;
+    }
+    startOfCurrentHourEpochSeconds() {
+        const rval = this.toEpochSeconds(DateTime.local().setZone(this.timezone).set({ minute: 0, second: 0, millisecond: 0 }));
+        return rval;
+    }
+    startOfCurrentMinuteEpochSeconds() {
+        const rval = this.toEpochSeconds(DateTime.local().setZone(this.timezone).set({ second: 0, millisecond: 0 }));
+        return rval;
+    }
+    startOfCurrentSecondEpochSeconds() {
+        const rval = this.toEpochSeconds(DateTime.local().setZone(this.timezone).set({ millisecond: 0 }));
+        return rval;
+    }
+    startOfTodayEpochMS() {
+        const startOfToday = DateTime.local().setZone(this.timezone).set({ hour: 0, minute: 0, second: 0, millisecond: 0 }).toMillis();
+        return startOfToday;
+    }
+    dailySlotCount(slotWidthMs) {
+        return Math.ceil(86400000 / slotWidthMs);
+    }
+    currentTimeSlotIdx(slotWidthMs) {
+        if (slotWidthMs < 1) {
+            throw new Error('Cannot process with slot less than one ms wide');
+        }
+        const startOfToday = this.startOfTodayEpochMS();
+        const now = new Date().getTime();
+        const delta = now - startOfToday;
+        const idx = Math.floor(delta / slotWidthMs);
+        return idx;
+    }
+    matchingTimeSlotIdx(timestamp, slotWidthMs) {
+        if (slotWidthMs < 1) {
+            throw new Error('Cannot process with slot less than one ms wide');
+        }
+        const startOfDay = this.startOfMatchingDayEpochMS(timestamp);
+        const delta = timestamp - startOfDay;
+        const idx = Math.floor(delta / slotWidthMs);
+        return idx;
+    }
+    startOfCurrentSlotEpochMS(slotWidthMs) {
+        const startOfToday = this.startOfTodayEpochMS();
+        const currentIdx = this.currentTimeSlotIdx(slotWidthMs);
+        return startOfToday + currentIdx * slotWidthMs;
+    }
+    startOfMatchingSlotEpochMS(timestamp, slotWidthMs) {
+        const startOfDay = this.startOfMatchingDayEpochMS(timestamp);
+        const currentIdx = this.matchingTimeSlotIdx(timestamp, slotWidthMs);
+        return startOfDay + currentIdx * slotWidthMs;
+    }
+}
+TimeZoneRatchet.PACIFIC = new TimeZoneRatchet('America/Los_Angeles');

package/dist/es/lang/timeout-token.js

@@ -0,0 +1,15 @@
+import { Logger } from '../logger/logger';
+import { LoggerLevelName } from '../logger/logger-level-name';
+export class TimeoutToken {
+    constructor(title, timeoutMS) {
+        this.title = title;
+        this.timeoutMS = timeoutMS;
+        this.__timeoutTokenFlagField = true;
+    }
+    writeToLog(logLevel = LoggerLevelName.warn) {
+        Logger.logByLevel(logLevel, 'Timed out after %d ms waiting for results of %s', this.timeoutMS, this.title);
+    }
+    static isTimeoutToken(value) {
+        return !!value && !!value['__timeoutTokenFlagField'];
+    }
+}

package/dist/es/lang/transform-ratchet.js

@@ -0,0 +1,66 @@
+import { Logger } from '../logger/logger';
+export class TransformRatchet {
+    static transform(toTransform, rules = []) {
+        return TransformRatchet.transformGeneric(toTransform, rules, false, null);
+    }
+    static transformGeneric(toTransform, rules = [], isKey, context) {
+        let rval = null;
+        const type = typeof toTransform;
+        switch (type) {
+            case 'undefined':
+            case 'symbol':
+            case 'function':
+                rval = toTransform;
+                break;
+            case 'number':
+            case 'string':
+            case 'boolean':
+                rval = TransformRatchet.applyTransformToPrimitive(toTransform, rules, isKey, context);
+                break;
+            case 'object':
+                rval = TransformRatchet.applyTransformToObject(toTransform, rules, isKey, context);
+                break;
+            default:
+                throw new Error('Unrecognized type ' + type);
+        }
+        return rval;
+    }
+    static applyTransformToObject(toTransform, rules = [], isKey, context = null) {
+        Logger.silly('Tranform: %j, %s, %j', toTransform, isKey, context);
+        let rval = null;
+        if (toTransform != null) {
+            if (Array.isArray(toTransform)) {
+                rval = [];
+                toTransform.forEach((val) => {
+                    const newVal = TransformRatchet.transformGeneric(val, rules, isKey, toTransform);
+                    if (newVal != null) {
+                        rval.push(newVal);
+                    }
+                });
+            }
+            else {
+                rval = {};
+                Object.keys(toTransform).forEach((k) => {
+                    const oldValue = toTransform[k];
+                    const newKey = TransformRatchet.applyTransformToPrimitive(k, rules, true, toTransform);
+                    if (newKey != null) {
+                        let newValue = TransformRatchet.transformGeneric(oldValue, rules, false, toTransform);
+                        newValue = TransformRatchet.applyTransformToPrimitive(newValue, rules, false, toTransform);
+                        if (newValue != null) {
+                            rval[newKey] = newValue;
+                        }
+                    }
+                });
+                rval = TransformRatchet.applyTransformToPrimitive(rval, rules, false, toTransform);
+            }
+        }
+        return rval;
+    }
+    static applyTransformToPrimitive(toTransform, rules = [], isKey, context) {
+        let rval = toTransform;
+        rules.forEach((r) => {
+            rval = rval == null ? null : r.transform(rval, isKey, context);
+        });
+        return rval;
+    }
+}

package/dist/es/logger/classic-single-line-log-message-formatter.js

@@ -0,0 +1,13 @@
+import util from 'util';
+export class ClassicSingleLineLogMessageFormatter {
+    formatMessage(msg, meta) {
+        let tmp = null;
+        if (msg) {
+            tmp = '';
+            tmp += meta.options.trace ? meta.options.trace + ' ' : '';
+            tmp += '[' + msg.lvl + '] ';
+            tmp += util.format(msg.messageSource, ...msg.subsVars);
+        }
+        return tmp;
+    }
+}

package/dist/es/logger/log-message-builder.js

@@ -0,0 +1,47 @@
+export class LogMessageBuilder {
+    constructor(lvl, messageSource) {
+        if (!lvl) {
+            throw Error('Cannot set level to null/undefined');
+        }
+        this.wrapped = { lvl: lvl, timestamp: Date.now(), messageSource: messageSource };
+    }
+    clone() {
+        const rval = new LogMessageBuilder(this.wrapped.lvl, this.wrapped.messageSource);
+        rval.wrapped = Object.assign({}, this.wrapped);
+        return rval;
+    }
+    level(lvl) {
+        if (!lvl) {
+            throw Error('Cannot set level to null/undefined');
+        }
+        this.wrapped.lvl = lvl;
+        return this;
+    }
+    timestamp(val) {
+        if (!val) {
+            throw Error('Cannot set timestamp to null/undefined');
+        }
+        this.wrapped.timestamp = val;
+        return this;
+    }
+    messageSource(val) {
+        this.wrapped.messageSource = val;
+        return this;
+    }
+    subVars(val) {
+        this.wrapped.subsVars = val || [];
+        return this;
+    }
+    params(val) {
+        this.wrapped.params = val || {};
+        return this;
+    }
+    p(name, value) {
+        this.wrapped.params = this.wrapped.params || {};
+        this.wrapped.params[name] = value;
+        return this;
+    }
+    toMessage() {
+        return Object.assign({}, this.wrapped);
+    }
+}

package/dist/es/logger/log-message-format-type.js

@@ -0,0 +1,6 @@
+export var LogMessageFormatType;
+(function (LogMessageFormatType) {
+    LogMessageFormatType["ClassicSingleLine"] = "ClassicSingleLine";
+    LogMessageFormatType["StructuredJson"] = "StructuredJson";
+    LogMessageFormatType["None"] = "None";
+})(LogMessageFormatType || (LogMessageFormatType = {}));

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

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

package/dist/es/logger/log-message-processor.js

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

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

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

package/dist/es/logger/log-snapshot.js

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

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

@@ -0,0 +1,201 @@
+import { LoggerRingBuffer } from './logger-ring-buffer';
+import { LoggerLevelName } from './logger-level-name';
+import { LoggerUtil } from './logger-util';
+import { LogMessageFormatType } from './log-message-format-type';
+import { ClassicSingleLineLogMessageFormatter } from './classic-single-line-log-message-formatter';
+import { NoneLogMessageFormatter } from './none-log-message-formatter';
+import { StructuredJsonLogMessageFormatter } from './structured-json-log-message-formatter';
+import { StringRatchet } from '../lang/string-ratchet';
+export class LoggerInstance {
+    constructor(loggerInstanceName = 'default', inOptions) {
+        this.loggerInstanceName = loggerInstanceName;
+        this.options = inOptions;
+    }
+    addPreProcessor(proc) {
+        if (proc) {
+            this._options.preProcessors = this._options.preProcessors || [];
+            this._options.preProcessors.push(proc);
+        }
+        return Object.assign([], this._options.preProcessors);
+    }
+    get ringBuffer() {
+        return this._ringBuffer;
+    }
+    dumpConfigurationIntoLog() {
+        this.error('ERROR enabled');
+        this.warn('WARN enabled');
+        this.info('INFO enabled');
+        this.verbose('VERBOSE enabled');
+        this.debug('DEBUG enabled');
+        this.silly('SILLY enabled');
+    }
+    dumpOptionsIntoLog() {
+        this.info('Options: %j', this.options);
+        if (this?.options?.preProcessors?.length) {
+            const labels = this.options.preProcessors.map((p) => StringRatchet.trimToNull(p.label()) || 'Unlabelled');
+            this.info('Preprocessors: %j', labels);
+        }
+    }
+    changeRingBufferSize(newSize) {
+        this._ringBuffer = null;
+        if (newSize) {
+            this._ringBuffer = new LoggerRingBuffer(newSize);
+            this._options.ringBufferSize = newSize;
+        }
+    }
+    updateTracePrefix(newValue) {
+        this._options.trace = newValue;
+    }
+    get options() {
+        return Object.assign({}, this._options);
+    }
+    set options(newOpts) {
+        this._options = Object.assign({}, newOpts);
+        if (this._options.ringBufferSize) {
+            this._ringBuffer = new LoggerRingBuffer(this._options.ringBufferSize);
+        }
+        switch (this._options.formatType) {
+            case LogMessageFormatType.None:
+                this._formatter = new NoneLogMessageFormatter();
+                break;
+            case LogMessageFormatType.StructuredJson:
+                this._formatter = new StructuredJsonLogMessageFormatter();
+                break;
+            default:
+                this._formatter = new ClassicSingleLineLogMessageFormatter();
+                break;
+        }
+        this._level = this._options.initialLevel;
+        this._handlerFunctionMap = LoggerUtil.handlerFunctionMap(this._options.outputFunction);
+        const oldId = this._loggerMeta ? this._loggerMeta.loggerInstanceId : null;
+        this._loggerMeta = {
+            options: this._options,
+            loggerInstanceName: this.loggerInstanceName,
+            loggerInstanceId: oldId || StringRatchet.createRandomHexString(8),
+        };
+    }
+    get level() {
+        return this._level;
+    }
+    set level(newLevel) {
+        if (!newLevel) {
+            throw new Error('Cannot set level to null/undefined');
+        }
+        this._level = newLevel;
+    }
+    consoleLogPassThru(level, ...input) {
+        if (LoggerUtil.levelIsEnabled(level, this._level)) {
+            let passThruPrefix = this._options.trace || '';
+            passThruPrefix += '[' + level + '] ';
+            input.unshift(passThruPrefix);
+            const fn = this._handlerFunctionMap.get(level) || LoggerUtil.defaultHandlerFunction;
+            fn(...input);
+        }
+    }
+    createLogMessage(level, params, format, ...input) {
+        const rval = {
+            lvl: level,
+            timestamp: Date.now(),
+            messageSource: format,
+            subsVars: input,
+            params: params,
+        };
+        return rval;
+    }
+    formatMessage(msg) {
+        const rval = msg ? this._formatter.formatMessage(msg, this._loggerMeta) : null;
+        return rval;
+    }
+    formatMessages(msgs) {
+        const rval = (msgs || []).map((m) => this.formatMessage(m)).filter((m) => !!m);
+        return rval;
+    }
+    recordMessageBuilder(msgBuild) {
+        return this.recordMessage(msgBuild.toMessage());
+    }
+    recordMessage(inMsg) {
+        let rval = null;
+        if (LoggerUtil.levelIsEnabled(inMsg.lvl, this._level)) {
+            let msg = Object.assign({}, inMsg);
+            if (this._options.preProcessors?.length) {
+                for (let i = 0; i < this._options.preProcessors.length; i++) {
+                    msg = this._options.preProcessors[i].process(msg);
+                }
+            }
+            rval = this.formatMessage(msg);
+            if (rval) {
+                const fn = this._handlerFunctionMap.get(msg.lvl) || LoggerUtil.defaultHandlerFunction;
+                fn(rval);
+                if (this._ringBuffer) {
+                    this._ringBuffer.addToRingBuffer(msg);
+                }
+            }
+        }
+        else {
+        }
+        return rval;
+    }
+    error(format, ...input) {
+        const msg = this.createLogMessage(LoggerLevelName.error, {}, format, ...input);
+        return this.recordMessage(msg);
+    }
+    errorP(...input) {
+        this.consoleLogPassThru(LoggerLevelName.error, ...input);
+    }
+    warn(format, ...input) {
+        const msg = this.createLogMessage(LoggerLevelName.warn, {}, format, ...input);
+        return this.recordMessage(msg);
+    }
+    warnP(...input) {
+        this.consoleLogPassThru(LoggerLevelName.warn, ...input);
+    }
+    info(format, ...input) {
+        const msg = this.createLogMessage(LoggerLevelName.info, {}, format, ...input);
+        return this.recordMessage(msg);
+    }
+    infoP(...input) {
+        this.consoleLogPassThru(LoggerLevelName.info, ...input);
+    }
+    verbose(format, ...input) {
+        const msg = this.createLogMessage(LoggerLevelName.verbose, {}, format, ...input);
+        return this.recordMessage(msg);
+    }
+    verboseP(...input) {
+        this.consoleLogPassThru(LoggerLevelName.verbose, ...input);
+    }
+    debug(format, ...input) {
+        const msg = this.createLogMessage(LoggerLevelName.debug, {}, format, ...input);
+        return this.recordMessage(msg);
+    }
+    debugP(...input) {
+        this.consoleLogPassThru(LoggerLevelName.debug, ...input);
+    }
+    silly(format, ...input) {
+        const msg = this.createLogMessage(LoggerLevelName.silly, {}, format, ...input);
+        return this.recordMessage(msg);
+    }
+    sillyP(...input) {
+        this.consoleLogPassThru(LoggerLevelName.silly, ...input);
+    }
+    logByLevel(level, format, ...input) {
+        const msg = this.createLogMessage(level, {}, format, ...input);
+        this.recordMessage(msg);
+    }
+    importMessages(msgs, prefixIn = '', addTimestamp = true) {
+        const prefix = prefixIn || '';
+        if (msgs && msgs.length > 0) {
+            this.silly('Received import data : %d msgs', msgs.length);
+            msgs.forEach((m) => {
+                if (m.messageSource) {
+                    let mOut = prefix;
+                    if (addTimestamp) {
+                        const ts = String(new Date()).substring(15, 24);
+                        mOut += ' (' + ts + ') : ';
+                        mOut += m.messageSource;
+                    }
+                    this.logByLevel(m.lvl, mOut);
+                }
+            });
+        }
+    }
+}

package/dist/es/logger/logger-level-name.js

@@ -0,0 +1,9 @@
+export var LoggerLevelName;
+(function (LoggerLevelName) {
+    LoggerLevelName["error"] = "error";
+    LoggerLevelName["warn"] = "warn";
+    LoggerLevelName["info"] = "info";
+    LoggerLevelName["verbose"] = "verbose";
+    LoggerLevelName["debug"] = "debug";
+    LoggerLevelName["silly"] = "silly";
+})(LoggerLevelName || (LoggerLevelName = {}));

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

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

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

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

package/dist/es/logger/logger-output-function.js

@@ -0,0 +1,6 @@
+export var LoggerOutputFunction;
+(function (LoggerOutputFunction) {
+    LoggerOutputFunction["Console"] = "Console";
+    LoggerOutputFunction["ConsoleNoDebug"] = "ConsoleNoDebug";
+    LoggerOutputFunction["StdOut"] = "StdOut";
+})(LoggerOutputFunction || (LoggerOutputFunction = {}));