.

node_modules/bs-logger/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { LogMethod, Logger, createLogger, lastSequenceNumber, resetSequence } from './logger';
+import { LogContext, LogContexts } from './logger/context';
+import { LogLevelName, LogLevels, logLevelNameFor, parseLogLevel } from './logger/level';
+import { LogMessage, LogMessageFormatter, LogMessageTranslator, registerLogFormatter, resetLogFormatters } from './logger/message';
+import { rootLogger, setup } from './logger/root';
+import { DEFAULT_LOG_TARGET, LogTarget, parseLogTargets } from './logger/target';
+import * as testing from './testing';
+export { rootLogger as default, rootLogger as logger, setup, createLogger, DEFAULT_LOG_TARGET, lastSequenceNumber, LogContext, LogContexts, Logger, LogLevelName, logLevelNameFor, LogLevels, LogMessage, LogMessageFormatter, LogMessageTranslator, LogMethod, LogTarget, parseLogLevel, parseLogTargets, registerLogFormatter, resetLogFormatters, resetSequence, testing, };

node_modules/bs-logger/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var logger_1 = require("./logger");
+exports.createLogger = logger_1.createLogger;
+exports.lastSequenceNumber = logger_1.lastSequenceNumber;
+exports.resetSequence = logger_1.resetSequence;
+var context_1 = require("./logger/context");
+exports.LogContexts = context_1.LogContexts;
+var level_1 = require("./logger/level");
+exports.LogLevels = level_1.LogLevels;
+exports.logLevelNameFor = level_1.logLevelNameFor;
+exports.parseLogLevel = level_1.parseLogLevel;
+var message_1 = require("./logger/message");
+exports.registerLogFormatter = message_1.registerLogFormatter;
+exports.resetLogFormatters = message_1.resetLogFormatters;
+var root_1 = require("./logger/root");
+exports.default = root_1.rootLogger;
+exports.logger = root_1.rootLogger;
+exports.setup = root_1.setup;
+var target_1 = require("./logger/target");
+exports.DEFAULT_LOG_TARGET = target_1.DEFAULT_LOG_TARGET;
+exports.parseLogTargets = target_1.parseLogTargets;
+var testing = __importStar(require("./testing"));
+exports.testing = testing;

node_modules/bs-logger/dist/logger/context.d.ts

@@ -0,0 +1,16 @@
+declare enum LogContexts {
+    application = "application",
+    hostname = "hostname",
+    logLevel = "logLevel",
+    namespace = "namespace",
+    package = "package"
+}
+interface LogContext {
+    [key: string]: any;
+    [LogContexts.application]?: string;
+    [LogContexts.hostname]?: string;
+    [LogContexts.logLevel]?: number;
+    [LogContexts.namespace]?: string;
+    [LogContexts.package]?: string;
+}
+export { LogContext, LogContexts };

node_modules/bs-logger/dist/logger/context.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var LogContexts;
+(function (LogContexts) {
+    LogContexts["application"] = "application";
+    LogContexts["hostname"] = "hostname";
+    LogContexts["logLevel"] = "logLevel";
+    LogContexts["namespace"] = "namespace";
+    LogContexts["package"] = "package";
+})(LogContexts || (LogContexts = {}));
+exports.LogContexts = LogContexts;

node_modules/bs-logger/dist/logger/index.d.ts

@@ -0,0 +1,37 @@
+import { LogContext } from './context';
+import { LogMessageTranslator } from './message';
+import { LogTarget } from './target';
+interface LogMethod {
+    (message: string, ...args: any[]): void;
+    (context: LogContext, message: string, ...args: any[]): void;
+    isEmptyFunction?: boolean;
+}
+interface LogChildMethod {
+    (context: LogContext): Logger;
+    (translate: LogMessageTranslator): Logger;
+}
+interface LogWrapMethod {
+    <F extends (...args: any[]) => any>(func: F): F;
+    <F extends (...args: any[]) => any>(message: string, func: F): F;
+    <F extends (...args: any[]) => any>(context: LogContext, message: string, func: F): F;
+    <F extends (...args: any[]) => any>(level: number, message: string, func: F): F;
+}
+interface Logger extends LogMethod {
+    trace: LogMethod;
+    debug: LogMethod;
+    info: LogMethod;
+    warn: LogMethod;
+    error: LogMethod;
+    fatal: LogMethod;
+    child: LogChildMethod;
+    wrap: LogWrapMethod;
+}
+declare const resetSequence: (next?: number) => void;
+declare const lastSequenceNumber: () => number;
+interface CreateLoggerOptions {
+    context?: LogContext;
+    translate?: LogMessageTranslator;
+    targets?: string | LogTarget[];
+}
+declare const createLogger: ({ context: baseContext, targets: logTargets, translate: logTranslator, }?: CreateLoggerOptions) => Logger;
+export { createLogger, lastSequenceNumber, Logger, LogMethod, resetSequence, CreateLoggerOptions };

node_modules/bs-logger/dist/logger/index.js

@@ -0,0 +1,164 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("util");
+var context_1 = require("./context");
+var level_1 = require("./level");
+var target_1 = require("./target");
+var lastSeqNumber = 0;
+var resetSequence = function (next) {
+    if (next === void 0) { next = 1; }
+    lastSeqNumber = next - 1;
+};
+exports.resetSequence = resetSequence;
+var lastSequenceNumber = function () { return lastSeqNumber; };
+exports.lastSequenceNumber = lastSequenceNumber;
+var createEmptyFunction = function () {
+    return Object.defineProperty(function emptyFunction() { }, 'isEmptyFunction', { value: true });
+};
+var createEmptyLogger = function () {
+    var log = createEmptyFunction();
+    log.child = function () { return createEmptyLogger(); };
+    log.wrap = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return args.pop();
+    };
+    level_1.LogLevelNames.forEach(function (name) {
+        log[name] = log;
+    });
+    return log;
+};
+var createLogger = function (_a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.context, baseContext = _c === void 0 ? {} : _c, _d = _b.targets, logTargets = _d === void 0 ? target_1.DEFAULT_LOG_TARGET : _d, logTranslator = _b.translate;
+    var targets = typeof logTargets === 'string' ? target_1.parseLogTargets(logTargets) : logTargets;
+    if (targets.length === 0) {
+        return createEmptyLogger();
+    }
+    var log = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var time = Date.now();
+        var sequence = ++lastSeqNumber;
+        var context;
+        if (typeof args[0] === 'string') {
+            context = __assign({}, baseContext);
+        }
+        else {
+            context = __assign({}, baseContext, args.shift());
+        }
+        var msg = args.shift();
+        var logLevel = context[context_1.LogContexts.logLevel];
+        var destTargets = logLevel == null ? targets : targets.filter(function (t) { return logLevel >= t.minLevel; });
+        if (destTargets.length === 0) {
+            return;
+        }
+        var message = util_1.format.apply(void 0, __spread([msg], args));
+        var logMessage = {
+            context: context,
+            time: time,
+            sequence: sequence,
+            message: message,
+        };
+        if (logTranslator) {
+            logMessage = logTranslator(logMessage);
+        }
+        destTargets.forEach(function (t) { return t.stream.write(t.format(logMessage) + "\n"); });
+    };
+    log.child = function (ctxOrTranslator) {
+        var isTranslator = typeof ctxOrTranslator === 'function';
+        var childContext = isTranslator ? __assign({}, baseContext) : __assign({}, baseContext, ctxOrTranslator);
+        var translate;
+        if (isTranslator) {
+            if (logTranslator) {
+                translate = function (msg) { return ctxOrTranslator(logTranslator(msg)); };
+            }
+            else {
+                translate = ctxOrTranslator;
+            }
+        }
+        else {
+            translate = logTranslator;
+        }
+        return createLogger({ context: childContext, targets: targets, translate: translate });
+    };
+    log.wrap = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var _a;
+        var _b = __read(Array(3 - args.length).concat(args), 3), ctx = _b[0], msg = _b[1], func = _b[2];
+        var context = typeof ctx === 'number' ? __assign({}, baseContext, (_a = {}, _a[context_1.LogContexts.logLevel] = ctx, _a)) : __assign({}, baseContext, ctx);
+        var logLevel = context[context_1.LogContexts.logLevel];
+        if (typeof logLevel === 'number' && targets.every(function (t) { return t.minLevel > logLevel; })) {
+            return func;
+        }
+        var message = msg == null ? "calling " + (func.name || '[anonymous]') + "()" : msg;
+        return function wrapped() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            log(__assign({ call: { args: args } }, context), message);
+            return func.apply(this, args);
+        };
+    };
+    level_1.LogLevelNames.forEach(function (name) {
+        var _a;
+        var level = level_1.LogLevels[name];
+        var extraContext = (_a = {}, _a[context_1.LogContexts.logLevel] = level, _a);
+        log[name] = function (ctxOrMsg) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            if (targets.length === 0 || targets.every(function (t) { return t.minLevel > level; })) {
+                log[name] = createEmptyFunction();
+                return;
+            }
+            if (typeof ctxOrMsg === 'string') {
+                log.apply(void 0, __spread([extraContext, ctxOrMsg], args));
+            }
+            else {
+                log.apply(void 0, __spread([__assign({}, ctxOrMsg, extraContext)], args));
+            }
+        };
+    });
+    return log;
+};
+exports.createLogger = createLogger;

node_modules/bs-logger/dist/logger/level.d.ts

@@ -0,0 +1,25 @@
+declare const LogLevels: {
+    trace: number;
+    debug: number;
+    info: number;
+    warn: number;
+    error: number;
+    fatal: number;
+    readonly lower: number;
+    readonly higher: number;
+};
+declare type LogLevelName = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+declare const LogLevelNames: LogLevelName[];
+declare const LogLevelValues: number[];
+interface LogLevelsScaleEntry {
+    range: {
+        from: number;
+        next: number;
+    };
+    name: string;
+    test(level: number): boolean;
+}
+declare const LogLevelsScale: ReadonlyArray<LogLevelsScaleEntry>;
+declare const logLevelNameFor: (level?: number | undefined) => string;
+declare const parseLogLevel: (level: string | number) => number | undefined;
+export { logLevelNameFor, LogLevels, LogLevelNames, LogLevelValues, LogLevelsScale, parseLogLevel, LogLevelName };

node_modules/bs-logger/dist/logger/level.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var cache_getters_1 = require("../utils/cache-getters");
+var LogLevels = cache_getters_1.cacheGetters({
+    trace: 10,
+    debug: 20,
+    info: 30,
+    warn: 40,
+    error: 50,
+    fatal: 60,
+    get lower() {
+        return LogLevels.trace;
+    },
+    get higher() {
+        return LogLevels.fatal;
+    },
+}, 'lower', 'higher');
+exports.LogLevels = LogLevels;
+var LogLevelNames = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
+exports.LogLevelNames = LogLevelNames;
+var LogLevelValues = LogLevelNames.map(function (name) { return LogLevels[name]; });
+exports.LogLevelValues = LogLevelValues;
+var LogLevelsScale = LogLevelNames.map(function (name, index, _a) {
+    var length = _a.length;
+    var first = index === 0;
+    var last = index === length - 1;
+    var from = first ? -Infinity : LogLevelValues[index];
+    var next = last ? +Infinity : LogLevelValues[index + 1];
+    var test;
+    if (first) {
+        test = function (level) { return level < next; };
+    }
+    else if (last) {
+        test = function (level) { return level >= from; };
+    }
+    else {
+        test = function (level) { return level < next && level >= from; };
+    }
+    return { range: { from: from, next: next }, name: name, test: test };
+});
+exports.LogLevelsScale = LogLevelsScale;
+var logLevelNameFor = function (level) {
+    if (level == null || isNaN(level)) {
+        return LogLevelNames[0];
+    }
+    return LogLevelsScale.find(function (_a) {
+        var test = _a.test;
+        return test(level);
+    }).name;
+};
+exports.logLevelNameFor = logLevelNameFor;
+var parseLogLevel = function (level) {
+    if (typeof level === 'string') {
+        level = level.toLowerCase();
+        if (level in LogLevels) {
+            return LogLevels[level];
+        }
+        return /^\s*[0-9]+\s*$/.test(level) ? parseInt(level.trim(), 10) : undefined;
+    }
+    return typeof level === 'number' && !isNaN(level) ? +level : undefined;
+};
+exports.parseLogLevel = parseLogLevel;

node_modules/bs-logger/dist/logger/message.d.ts

@@ -0,0 +1,18 @@
+import { LogContext } from './context';
+interface LogMessage {
+    context: LogContext;
+    message: string;
+    sequence: number;
+    time: number;
+}
+declare type LogMessageFormatter = (msg: LogMessage) => string;
+declare type LogMessageTranslator = (msg: LogMessage) => LogMessage;
+interface LogFormattersMap {
+    json: LogMessageFormatter;
+    simple: LogMessageFormatter;
+    [key: string]: LogMessageFormatter;
+}
+declare let LogFormatters: LogFormattersMap;
+declare const resetLogFormatters: () => void;
+declare const registerLogFormatter: (name: string, format: LogMessageFormatter) => void;
+export { LogMessage, LogMessageTranslator, LogMessageFormatter, LogFormatters, resetLogFormatters, registerLogFormatter, };

node_modules/bs-logger/dist/logger/message.js

@@ -0,0 +1,37 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
+var context_1 = require("./context");
+var level_1 = require("./level");
+var LogFormatters = defaultLogFormatters();
+exports.LogFormatters = LogFormatters;
+var resetLogFormatters = function () {
+    exports.LogFormatters = LogFormatters = defaultLogFormatters();
+};
+exports.resetLogFormatters = resetLogFormatters;
+var registerLogFormatter = function (name, format) {
+    LogFormatters[name] = format;
+};
+exports.registerLogFormatter = registerLogFormatter;
+function defaultLogFormatters() {
+    return {
+        json: function (msg) { return fast_json_stable_stringify_1.default(__assign({}, msg, { time: new Date(msg.time) }), { cycles: true }); },
+        simple: function (msg) {
+            return (msg.context[context_1.LogContexts.package] || msg.context[context_1.LogContexts.application] || 'main') + "[" + (msg.context[context_1.LogContexts.namespace] || 'root') + "] (" + level_1.logLevelNameFor(msg.context[context_1.LogContexts.logLevel]).toUpperCase() + ") " + msg.message;
+        },
+    };
+}

node_modules/bs-logger/dist/logger/root.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from '.';
+declare const setup: (factory?: () => Logger) => void;
+declare const rootLogger: Logger;
+export { rootLogger, setup };

node_modules/bs-logger/dist/logger/root.js

@@ -0,0 +1,79 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var e_1, _a;
+var cache_getters_1 = require("../utils/cache-getters");
+var _1 = require(".");
+var level_1 = require("./level");
+var cache;
+var setup = function (factory) {
+    if (factory === void 0) { factory = function () { return _1.createLogger({ targets: process.env.LOG_TARGETS || process.env.LOG_TARGET }); }; }
+    cache = cache_getters_1.cacheGetters({
+        get root() {
+            return factory();
+        },
+    }, 'root');
+};
+exports.setup = setup;
+var rootLogger = (function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return cache.root.apply(cache, __spread(args));
+});
+exports.rootLogger = rootLogger;
+var props = __spread(level_1.LogLevelNames, ['child', 'wrap']);
+var _loop_1 = function (prop) {
+    Object.defineProperty(rootLogger, prop, {
+        enumerable: true,
+        configurable: true,
+        get: function () {
+            return cache.root[prop];
+        },
+    });
+};
+try {
+    for (var props_1 = __values(props), props_1_1 = props_1.next(); !props_1_1.done; props_1_1 = props_1.next()) {
+        var prop = props_1_1.value;
+        _loop_1(prop);
+    }
+}
+catch (e_1_1) { e_1 = { error: e_1_1 }; }
+finally {
+    try {
+        if (props_1_1 && !props_1_1.done && (_a = props_1.return)) _a.call(props_1);
+    }
+    finally { if (e_1) throw e_1.error; }
+}
+cache_getters_1.cacheGetters.apply(void 0, __spread([rootLogger], props));
+setup();

node_modules/bs-logger/dist/logger/target.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { Writable } from 'stream';
+import { LogMessageFormatter } from './message';
+interface LogTarget {
+    stream: Writable;
+    minLevel: number;
+    format: LogMessageFormatter;
+}
+declare const parseLogTargets: (targetString?: string | undefined) => LogTarget[];
+declare const DEFAULT_LOG_TARGET: string;
+export { LogTarget, DEFAULT_LOG_TARGET, parseLogTargets };

node_modules/bs-logger/dist/logger/target.js

@@ -0,0 +1,90 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = require("fs");
+var path_1 = require("path");
+var cache_getters_1 = require("../utils/cache-getters");
+var level_1 = require("./level");
+var message_1 = require("./message");
+var logTargetWithLevelRegex = new RegExp("^\\s*(.+):([0-9]+|" + level_1.LogLevelNames.join('|') + ")\\s*$", 'i');
+var parseLogTargets = function (targetString) {
+    var items = (targetString || '').split(/([^\\]),/g).reduce(function (list, item, index) {
+        if (index % 2 === 1) {
+            list[list.length - 1] += item;
+        }
+        else {
+            list.push(item);
+        }
+        return list;
+    }, []);
+    return items.reduce(function (targets, str) {
+        var format;
+        str = str.replace(/^(.+)%([a-z_][a-z0-9_]*)$/, function (_, before, key) {
+            format = message_1.LogFormatters[key];
+            return before;
+        });
+        var pieces = str.match(logTargetWithLevelRegex);
+        var file;
+        var level;
+        if (pieces) {
+            file = pieces[1].trim();
+            level = pieces[2].trim();
+        }
+        else {
+            file = str.trim();
+        }
+        var append = file.endsWith('+');
+        if (append) {
+            file = file.slice(0, -1).trim();
+        }
+        file = file.replace(/\\,/g, ',');
+        if (!file) {
+            return targets;
+        }
+        var isStandardFd = /^(stdout|stderr)$/i.test(file);
+        if (format == null) {
+            format = isStandardFd ? message_1.LogFormatters.simple : message_1.LogFormatters.json;
+        }
+        var target = cache_getters_1.cacheGetters({
+            format: format,
+            get minLevel() {
+                return level_1.parseLogLevel(level) || -Infinity;
+            },
+            get stream() {
+                if (isStandardFd) {
+                    return process[file.toLowerCase()];
+                }
+                else {
+                    return fs_1.createWriteStream(path_1.resolve(process.cwd(), file), {
+                        flags: append ? 'a' : 'w',
+                        autoClose: true,
+                        encoding: 'utf8',
+                    });
+                }
+            },
+        }, 'minLevel', 'stream');
+        return __spread(targets, [target]);
+    }, []);
+};
+exports.parseLogTargets = parseLogTargets;
+var DEFAULT_LOG_TARGET = "stderr:" + level_1.LogLevels.warn;
+exports.DEFAULT_LOG_TARGET = DEFAULT_LOG_TARGET;

node_modules/bs-logger/dist/testing/index.d.ts

@@ -0,0 +1,8 @@
+import { CreateLoggerOptions, Logger } from '../logger';
+import { ExtendedArray, LogTargetMock, extendArray } from './target-mock';
+declare const setupForTesting: (target?: LogTargetMock) => void;
+interface LoggerMock extends Logger {
+    readonly target: LogTargetMock;
+}
+declare const createLoggerMock: (options?: CreateLoggerOptions | undefined, target?: LogTargetMock) => LoggerMock;
+export { LogTargetMock, ExtendedArray, extendArray, setupForTesting as setup, createLoggerMock, LoggerMock };

node_modules/bs-logger/dist/testing/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var logger_1 = require("../logger");
+var root_1 = require("../logger/root");
+var target_mock_1 = require("./target-mock");
+exports.LogTargetMock = target_mock_1.LogTargetMock;
+exports.extendArray = target_mock_1.extendArray;
+var setupForTesting = function (target) {
+    if (target === void 0) { target = new target_mock_1.LogTargetMock(); }
+    root_1.setup(function () { return createLoggerMock(undefined, target); });
+};
+exports.setup = setupForTesting;
+var createLoggerMock = function (options, target) {
+    if (target === void 0) { target = new target_mock_1.LogTargetMock(); }
+    var opt = __assign({}, options, { targets: [target] });
+    return Object.assign(logger_1.createLogger(opt), { target: target });
+};
+exports.createLoggerMock = createLoggerMock;

node_modules/bs-logger/dist/testing/target-mock.d.ts

@@ -0,0 +1,28 @@
+import { LogMessage } from '../logger/message';
+import { LogTarget } from '../logger/target';
+interface ExtendedArray<T> extends Array<T> {
+    readonly last: T | undefined;
+}
+interface LogLevelMap<T> {
+    trace: T;
+    debug: T;
+    info: T;
+    warn: T;
+    error: T;
+    fatal: T;
+}
+declare const extendArray: <T>(array: T[]) => ExtendedArray<T>;
+declare class LogTargetMock implements LogTarget {
+    minLevel: number;
+    readonly messages: ExtendedArray<LogMessage> & LogLevelMap<ExtendedArray<LogMessage>>;
+    readonly lines: ExtendedArray<string> & LogLevelMap<ExtendedArray<string>>;
+    readonly stream: LogTarget['stream'];
+    constructor(minLevel?: number);
+    format(msg: LogMessage): string;
+    clear(): void;
+    filteredMessages(level: number, untilLevel?: number): ExtendedArray<LogMessage>;
+    filteredMessages(level: null): ExtendedArray<LogMessage>;
+    filteredLines(level: number, untilLevel?: number): ExtendedArray<string>;
+    filteredLines(level: null): ExtendedArray<string>;
+}
+export { LogTargetMock, extendArray, ExtendedArray };

node_modules/bs-logger/dist/testing/target-mock.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var context_1 = require("../logger/context");
+var level_1 = require("../logger/level");
+var extendArray = function (array) {
+    return Object.defineProperty(array, 'last', {
+        configurable: true,
+        get: function () {
+            return this[this.length - 1];
+        },
+    });
+};
+exports.extendArray = extendArray;
+var LogTargetMock = (function () {
+    function LogTargetMock(minLevel) {
+        if (minLevel === void 0) { minLevel = -Infinity; }
+        var _this = this;
+        this.minLevel = minLevel;
+        this.messages = Object.defineProperties(extendArray([]), {
+            trace: { get: function () { return _this.filteredMessages(level_1.LogLevels.trace); } },
+            debug: { get: function () { return _this.filteredMessages(level_1.LogLevels.debug); } },
+            info: { get: function () { return _this.filteredMessages(level_1.LogLevels.info); } },
+            warn: { get: function () { return _this.filteredMessages(level_1.LogLevels.warn); } },
+            error: { get: function () { return _this.filteredMessages(level_1.LogLevels.error); } },
+            fatal: { get: function () { return _this.filteredMessages(level_1.LogLevels.fatal); } },
+        });
+        this.lines = Object.defineProperties(extendArray([]), {
+            trace: { get: function () { return _this.filteredLines(level_1.LogLevels.trace); } },
+            debug: { get: function () { return _this.filteredLines(level_1.LogLevels.debug); } },
+            info: { get: function () { return _this.filteredLines(level_1.LogLevels.info); } },
+            warn: { get: function () { return _this.filteredLines(level_1.LogLevels.warn); } },
+            error: { get: function () { return _this.filteredLines(level_1.LogLevels.error); } },
+            fatal: { get: function () { return _this.filteredLines(level_1.LogLevels.fatal); } },
+        });
+        this.stream = {
+            write: function (msg) { return !!_this.lines.push(msg); },
+        };
+    }
+    LogTargetMock.prototype.format = function (msg) {
+        this.messages.push(msg);
+        var lvl = msg.context[context_1.LogContexts.logLevel];
+        if (lvl != null) {
+            return "[level:" + lvl + "] " + msg.message;
+        }
+        return msg.message;
+    };
+    LogTargetMock.prototype.clear = function () {
+        this.messages.splice(0, this.messages.length);
+        this.lines.splice(0, this.lines.length);
+    };
+    LogTargetMock.prototype.filteredMessages = function (level, untilLevel) {
+        var filter;
+        if (level == null) {
+            filter = function (m) { return m.context[context_1.LogContexts.logLevel] == null; };
+        }
+        else if (untilLevel != null) {
+            filter = function (m) {
+                var lvl = m.context[context_1.LogContexts.logLevel];
+                return lvl != null && lvl >= level && lvl <= untilLevel;
+            };
+        }
+        else {
+            filter = function (m) { return m.context[context_1.LogContexts.logLevel] === level; };
+        }
+        return extendArray(this.messages.filter(filter));
+    };
+    LogTargetMock.prototype.filteredLines = function (level, untilLevel) {
+        var extractLevel = function (line) {
+            var level = (line.match(/^\[level:([0-9]+)\] /) || [])[1];
+            return level == null ? undefined : parseInt(level, 10);
+        };
+        var filter;
+        if (level == null) {
+            filter = function (line) { return extractLevel(line) === undefined; };
+        }
+        else if (untilLevel != null) {
+            filter = function (line) {
+                var lvl = extractLevel(line);
+                return lvl != null && lvl >= level && lvl <= untilLevel;
+            };
+        }
+        else {
+            filter = function (line) { return extractLevel(line) === level; };
+        }
+        return extendArray(this.lines.filter(filter));
+    };
+    return LogTargetMock;
+}());
+exports.LogTargetMock = LogTargetMock;

node_modules/bs-logger/dist/utils/cache-getters.d.ts

@@ -0,0 +1,2 @@
+declare const cacheGetters: <T>(target: T, ...props: (keyof T)[]) => T;
+export { cacheGetters };

node_modules/bs-logger/dist/utils/cache-getters.js

@@ -0,0 +1,40 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
+            t[p[i]] = s[p[i]];
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var cacheGetters = function (target) {
+    var props = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        props[_i - 1] = arguments[_i];
+    }
+    props.forEach(function (prop) {
+        var desc = Object.getOwnPropertyDescriptor(target, prop);
+        var set = desc.set, previousGet = desc.get, partial = __rest(desc, ["set", "get"]);
+        desc.get = function get() {
+            var value = previousGet.call(this);
+            Object.defineProperty(this, prop, __assign({}, partial, { value: value }));
+            return value;
+        };
+        Object.defineProperty(target, prop, desc);
+    });
+    return target;
+};
+exports.cacheGetters = cacheGetters;