typespeed 2.0.6 → 2.0.7

package/test/node_modules/tracer/lib/color_console.js

@@ -0,0 +1,15 @@
+"use strict";
+var colors = require('colors/safe');
+module.exports = function(conf) {
+	return require('./console')({
+		filters : {
+			//log : do nothing
+			trace : colors.magenta,
+			debug : colors.cyan,
+			info : colors.green,
+			warn : colors.yellow,
+			error : colors.red.bold,
+			fatal : colors.red.bold
+		}
+	}, conf);
+};

package/test/node_modules/tracer/lib/console.js

@@ -0,0 +1,165 @@
+"use strict";
+var tinytim = require('tinytim'), dateFormat = require('dateformat'), utils = require('./utils'), path = require('path'), settings = require('./settings').settings;
+
+var noop = function(){};
+
+var fwrap = function(fn){
+	return function(str){ return fn(str) };
+};
+
+// Stack trace format :
+// https://github.com/v8/v8/wiki/Stack%20Trace%20API
+var stackReg = /at\s+(.*)\s+\((.*):(\d*):(\d*)\)/i;
+var stackReg2 = /at\s+()(.*):(\d*):(\d*)/i;
+
+// main log method
+function logMain(config, level, title, format, filters, needstack, args) {
+	//check level of global settings
+	var gLevel = settings.level;
+	if (typeof (gLevel) == 'string')
+		gLevel = config.methods.indexOf(gLevel);
+	if (level < gLevel) { return; }
+
+	var data = {
+		timestamp : dateFormat(new Date(), config.dateformat),
+		message : "",
+		title : title,
+		level : level,
+		args : args
+	};
+	data.method = data.path = data.line = data.pos = data.file = data.folder = '';
+
+	if (needstack) {
+		// get call stack, and analyze it
+		// get all file,method and line number
+		var stacklist = (new Error()).stack.split('\n').slice(3);
+		var s = stacklist[config.stackIndex] || stacklist[0],
+			sp = stackReg.exec(s) || stackReg2.exec(s);
+		if (sp && sp.length === 5) {
+			data.method = sp[1];
+			data.path = sp[2];
+			data.line = sp[3];
+			data.pos = sp[4];
+			data.folder = path.dirname(config.rootDir && path.isAbsolute(config.rootDir)
+				? data.path.replace(new RegExp('^'+config.rootDir+path.sep+'?'), '')
+				: path.resolve(data.path));
+			data.file = path.basename(data.path);
+
+			data.stack = stacklist.join('\n');
+		}
+	}
+
+	config.preprocess(data);
+	var msg = utils.format.apply(config, data.args);
+	data.message = msg;
+
+	// call micro-template to ouput
+	data.output = tinytim.tim(format, data);
+
+	// save unprocessed output
+	data.rawoutput = data.output;
+
+	// process every filter method
+	var len = filters.length;
+	for ( var i = 0; i < len; i += 1) {
+		data.output = fwrap(filters[i])(data.output);
+		if (!data.output)
+			return data;
+		// cancel next process if return a false(include null, undefined)
+	}
+	// trans the final result
+	config.transport.forEach(function(tras) {
+		tras(data);
+	});
+	return data;
+}
+
+module.exports = (function() {
+	// default config
+	var _config = {
+		rootDir: '',
+		format : "{{timestamp}} <{{title}}> {{file}}:{{line}} ({{method}}) {{message}}",
+		dateformat : "isoDateTime",
+		preprocess : function() {
+		},
+		transport : function(data) {
+      if (data.title == 'warn') {
+        console.warn(data.output)
+      } else if (data.level > 4) {
+        console.error(data.output)
+      } else (
+        console.log(data.output)
+      )
+		},
+		filters : [],
+		level : 'log',
+		methods : [ 'log', 'trace', 'debug', 'info', 'warn', 'error', 'fatal' ],
+		stackIndex : 0,		// get the specified index of stack as file information. It is userful for development package.
+		inspectOpt : {
+			showHidden : false, //if true then the object's non-enumerable properties will be shown too. Defaults to false
+			depth : 2 //tells inspect how many times to recurse while formatting the object. This is useful for inspecting large complicated objects. Defaults to 2. To make it recurse indefinitely pass null.
+		},
+		supportConsoleMethods : true
+	};
+
+	var userConfig = arguments;
+	if(typeof userConfig[0] === 'string') {
+		userConfig = [eval("require")(userConfig[0])];
+	}
+
+	// union user's config and default
+	_config = utils.union(_config, userConfig);
+
+	var _self = {};
+
+	_config.format = Array.isArray(_config.format) ? _config.format
+		: [ _config.format ];
+
+	_config.filters = Array.isArray(_config.filters) ? _config.filters
+		: [ _config.filters ];
+
+	_config.transport = Array.isArray(_config.transport) ? _config.transport : [_config.transport];
+
+	var fLen = _config.filters.length, lastFilter;
+	if (fLen > 0)
+		if (Object.prototype.toString.call(_config.filters[--fLen]) != '[object Function]') {
+			lastFilter = _config.filters[fLen];
+			_config.filters = _config.filters.slice(0, fLen);
+		}
+
+	if (typeof (_config.level) == 'string')
+		_config.level = _config.methods.indexOf(_config.level);
+
+	_config.methods.forEach(function(title, i) {
+		if (i < _config.level)
+			_self[title] = noop;
+		else {
+			var format = _config.format[0];
+			if (_config.format.length === 2 && _config.format[1][title])
+				format = _config.format[1][title];
+			var needstack = /{{(method|path|line|pos|file|folder|stack)}}/i.test(format);
+
+			var filters;
+			if (lastFilter && lastFilter[title])
+				filters = Array.isArray(lastFilter[title]) ? lastFilter[title]
+					: [ lastFilter[title] ];
+			else
+				filters = _config.filters;
+
+			// interface
+			_self[title] = function() {
+				return logMain(_config, i, title, format, filters, needstack, arguments);
+			};
+		}
+	});
+
+	if(_config.supportConsoleMethods) {
+		Object.getOwnPropertyNames(console).forEach(function(title) {
+			if (!_self[title]) {
+				_self[title] = console[title];
+			}
+		});
+	}
+
+	return _self;
+});

package/test/node_modules/tracer/lib/dailyfile.js

@@ -0,0 +1,92 @@
+"use strict";
+var fs = require('fs'), dateFormat = require('dateformat'), tinytim = require('tinytim'), utils = require('./utils'), spawn = require('child_process').spawn, spawnSync = require('child_process').spawnSync;
+// var path = require('path');
+var os = require('os');
+var mkdirp = require('mkdirp');
+
+function checkLogFile(path) {
+    if (os.type() === 'Windows_NT') {
+        if (!fs.existsSync(path)) {
+            mkdirp(path);
+        }
+    } else {
+        spawnSync('mkdir', ['-p', path]);
+    }
+}
+
+module.exports = function (conf) {
+    var _conf = {
+        root: '.',
+        logPathFormat: '{{root}}/{{prefix}}.{{date}}.log',
+        splitFormat: 'yyyymmdd',
+        allLogsFileName: false,
+        maxLogFiles: 10
+    };
+
+    _conf = utils.union(_conf, [conf]);
+
+    function LogFile(prefix, date) {
+        this.date = date;
+        this.path = tinytim.tim(_conf.logPathFormat, { root: _conf.root, prefix: prefix, date: date });
+        checkLogFile(_conf.root);
+        this.stream = fs.createWriteStream(this.path, {
+            flags: "a",
+            encoding: "utf8",
+            mode: parseInt('0644', 8)
+            // When engines node >= 4.0.0, following notation will be better:
+            //mode: 0o644
+        });
+    }
+
+    LogFile.prototype.write = function (str) {
+        this.stream.write(str + "\n");
+    };
+
+    LogFile.prototype.destroy = function () {
+        if (this.stream) {
+            this.stream.end();
+            this.stream.destroySoon();
+            this.stream = null;
+        }
+    };
+
+    var _logMap = {};
+
+    function _push2File(str, title) {
+        if (_conf.allLogsFileName) {
+            var allLogFile = _logMap.allLogFile, now = dateFormat(new Date(), _conf.splitFormat);
+            if (allLogFile && allLogFile.date != now) {
+                allLogFile.destroy();
+                allLogFile = null;
+            }
+            if (!allLogFile) {
+                allLogFile = _logMap.allLogFile = new LogFile(_conf.allLogsFileName, now);
+                spawn('find', [_conf.root, '-type', 'f', '-name', '*.log', '-mtime', '+' + _conf.maxLogFiles, '-exec', 'rm', '{}', ';']);
+            }
+            allLogFile.write(str);
+        } else {
+            var logFile = _logMap[title], nowAgain = dateFormat(new Date(), _conf.splitFormat);
+            if (logFile && logFile.date != nowAgain) {
+                logFile.destroy();
+                logFile = null;
+            }
+            if (!logFile) {
+                logFile = _logMap[title] = new LogFile(title, nowAgain);
+                spawn('find', [_conf.root, '-type', 'f', '-name', '*.log', '-mtime', '+' + _conf.maxLogFiles, '-exec', 'rm', '{}', ';']);
+            }
+            logFile.write(str);
+        }
+    }
+
+    function dailyFileTransport(data) {
+        _push2File(data.output, data.title);
+    }
+
+    if (conf.transport) {
+        conf.transport = Array.isArray(conf.transport) ? conf.transport : [conf.transport];
+        conf.transport.push(dailyFileTransport)
+    } else {
+        conf.transport = [dailyFileTransport];
+    }
+    return require('./console')(conf);
+};

package/test/node_modules/tracer/lib/index.js

@@ -0,0 +1,10 @@
+"use strict";
+exports.console = require('./console');
+exports.colorConsole = require('./color_console');
+exports.dailyfile = require('./dailyfile');
+
+//global settings
+var settings = require('./settings');
+exports.close = settings.close;
+exports.setLevel = settings.setLevel;
+exports.getLevel = settings.getLevel;

package/test/node_modules/tracer/lib/settings.js

@@ -0,0 +1,25 @@
+"use strict";
+var settings = {
+	level : undefined
+}
+
+//end all of output
+var close = function(){
+	settings.level = Number.MAX_VALUE;
+}
+
+//dynamically change the log level, all of output
+var setLevel = function(level){
+	settings.level = level;
+}
+
+//get the current log level
+var getLevel = function(){
+	return settings.level;
+}
+
+
+exports.settings = settings;
+exports.close = close;
+exports.setLevel = setLevel;
+exports.getLevel = getLevel;

package/test/node_modules/tracer/lib/utils.js

@@ -0,0 +1,58 @@
+"use strict";
+exports.union = function(obj, args) {
+	for (var i = 0, len = args.length; i < len; i += 1) {
+		var source = args[i];
+		for ( var prop in source) {
+			obj[prop] = source[prop];
+		}
+	}
+	return obj;
+};
+
+var formatRegExp = /%[sdjt]/g;
+var util = require('util');
+exports.format = function(f) {
+	var inspectOpt = this.inspectOpt;
+	var args = arguments;
+	var i = 0;
+
+	if (typeof f !== 'string') {
+		var objects = [];
+		for (; i < args.length; i++) {
+			objects.push(util.inspect(args[i], inspectOpt));
+		}
+		return objects.join(' ');
+	}
+
+	i = 1;
+	var str = String(f).replace(formatRegExp, function(x) {
+		switch (x) {
+		case '%s':
+			return String(args[i++]);
+		case '%d':
+			return Number(args[i++]);
+		case '%j':
+			try {
+			    if (args[i] instanceof Error) {
+				return JSON.stringify(args[i++], ['message', 'stack', 'type', 'name']);
+        		    } else {
+            			return JSON.stringify(args[i++]);
+        		    }
+			} catch(e) {
+				return '[Circular]';
+			}
+		case '%t':
+			return util.inspect(args[i++], inspectOpt);
+		default:
+			return x;
+		}
+	});
+	for ( var len = args.length, x = args[i]; i < len; x = args[++i]) {
+		if (x === null || typeof x !== 'object') {
+			str += ' ' + x;
+		} else {
+			str += ' ' + util.inspect(x, inspectOpt);
+		}
+	}
+	return str;
+};

package/test/node_modules/tracer/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "tracer",
+  "description": "A powerful and customizable logging library for node.js. support color console with timestamp, line number, method name, file name and call stack. you can set transport to file, stream, database(ex: mongodb and clouddb, simpledb). keywords: log, logger, trace ",
+  "homepage": "http://github.com/baryon/tracer",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/baryon/tracer.git"
+  },
+  "version": "1.1.6",
+  "author": "LI Long <lilong@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "colors": "1.4.0",
+    "dateformat": "4.5.1",
+    "mkdirp": "^1.0.4",
+    "tinytim": "0.1.1"
+  },
+  "devDependencies": {
+    "cli-color": "^2.0.0",
+    "dtslint": "^4.2.1",
+    "eslint": "^7.12.1",
+    "mocha": "^10.0.0",
+    "mongoskin": "^0.3.7",
+    "nyc": "^15.1.0",
+    "ssri": ">=6.0.2",
+    "tslint": "^6.1.3",
+    "typescript": "^4.0.5"
+  },
+  "main": "./lib/index",
+  "types": "./types/index.d.ts",
+  "keywords": [
+    "log",
+    "logger",
+    "trace",
+    "debug"
+  ],
+  "scripts": {
+    "test": "mocha test/*",
+    "lint:fix": "eslint --fix .",
+    "lint": "eslint .",
+    "posttest": "npm run lint",
+    "test:coverage": "nyc npm run test",
+    "posttest:coverage": "npm run lint",
+    "dtslint": "dtslint types"
+  },
+  "files": [
+    "lib/*",
+    "types/index.d.ts"
+  ],
+  "engines": {
+    "node": ">= 0.10.0"
+  }
+}

package/test/node_modules/tracer/types/index.d.ts

@@ -0,0 +1,189 @@
+// TypeScript Version: 2.6
+
+export namespace Tracer {
+    export interface LogOutput {
+        /**
+         * Current time.
+         */
+        timestamp: string;
+        /**
+         * The result of formating the template and arguments in `args`.
+         */
+        message: string;
+        /**
+         * Method name, default is `log`, `trace`, `debug`, `info`, `warn`, `error`, `fatal`.
+         */
+        title: string;
+        /**
+         * Method level, default is `log`: 0, `trace`: 1, `debug`: 2, `info`: 3, `warn`: 4, `error`: 5, `fatal`: 6.
+         */
+        level: number;
+        /**
+         * Arguments of `Logger` method.
+         */
+        args: any[];
+        /**
+         * Method name of caller.
+         */
+        method: string;
+        /**
+         * File's path.
+         */
+        path: string;
+        /**
+         * Line number.
+         */
+        line: string;
+        /**
+         * Position.
+         */
+        pos: string;
+        /**
+         * folder path.
+         */
+        folder: string;
+        /**
+         * File's name.
+         */
+        file: string;
+        /**
+         * Call stack message.
+         */
+        stack: string;
+        /**
+         * The output to be written
+         */
+        output: string;
+
+        /**
+         * Any custom keys
+         */
+        [key: string]: any;
+    }
+
+    export type LevelOption<T, M extends string> = Partial<Record<M, T>>
+    export type FilterFunction = (data: string) => string | boolean | null | void;
+    export type TransportFunction = (data: LogOutput) => void;
+
+    export interface LoggerConfig<M extends string = "log" | "trace" | "debug" | "info" | "warn" | "error" | "fatal"> {
+        /**
+         * Output format (Using `tinytim` templating)
+         *
+         * Defaults to: `"{{timestamp}} <{{title}}> {{file}}:{{line}} ({{method}}) {{message}}"`
+         *
+         * Possible values:
+         * - timestamp: current time
+         * - title: method name, default is 'log', 'trace', 'debug', 'info', 'warn', 'error','fatal'
+         * - level: method level, default is 'log':0, 'trace':1, 'debug':2, 'info':3, 'warn':4, 'error':5, 'fatal':6
+         * - message: printf message, support %s string, %d number, %j JSON and auto inspect
+         * - file: file name
+         * - line: line number
+         * - pos: position
+         * - path: file's path
+         * - method: method name of caller
+         * - stack: call stack message
+         */
+        format?: string | [string, LevelOption<string, M>];
+         /**
+          * rootDir of folder path.
+          */
+        rootDir?: string;
+        /**
+         * Datetime format (Using `Date Format`)
+         */
+        dateformat?: string;
+        filters?: FilterFunction[] | LevelOption<FilterFunction | FilterFunction[], M> | Array<FilterFunction | LevelOption<FilterFunction | FilterFunction[], M>>;
+        /**
+         * Output the log, if level of log larger than or equal to `level`.
+         */
+        level?: string | number;
+        methods?: M[];
+        /**
+         * Get the specified index of stack as file information. It is useful for development package.
+         */
+        stackIndex?: number;
+        inspectOpt?: {
+            /**
+             * If true then the object's non-enumerable properties will be shown too. Defaults to false.
+             */
+            showHidden: boolean,
+            /**
+             * Tells inspect how many times to recurse while formatting the object.
+             * This is useful for inspecting large complicated objects.
+             * Defaults to 2. To make it recurse indefinitely pass null.
+             */
+            depth: number | null
+        };
+
+        /**
+         * Pre-process the log object.
+         */
+        preprocess?(data: LogOutput): void;
+        /**
+         * Transport function (e.g. console.log)
+         */
+        transport?: TransportFunction | TransportFunction[];
+    }
+    export interface DailyFileConfig {
+        /**
+         * All daily log file's dir, default to: `'.'`.
+         */
+        root?: string;
+        /**
+         * Log file path format.
+         *
+         * Default to: `'{{root}}/{{prefix}}.{{date}}.log'`
+         *
+         * Possible values:
+         * - `root`: all daily log file's dir, default to: `'.'`.
+         * - `prefix`: it equal to `allLogsFileName`, if `allLogsFileName` is provided; else it will be the method name.
+         * - `date`: today's date.
+         */
+        logPathFormat?: string;
+        /**
+         * Datetime format (Using `Date Format`)
+         */
+        splitFormat?: string;
+        /**
+         * If `allLogsFileName` is provided then all level logs will be move to one daily log file.
+         */
+        allLogsFileName?: boolean | string;
+        maxLogFiles?: number;
+    }
+
+    export type Logger<M extends string> = Record<M, (...args: any[]) => LogOutput>
+}
+
+/**
+ * Create a console for printing color log.
+ * @param [config] Configurate how logs are printed.
+ */
+export function colorConsole<M extends string>(config?: Tracer.LoggerConfig<M>): Tracer.Logger<M>;
+/**
+ * Create a console without color.
+ * @param [config] Configurate how logs are printed.
+ */
+export function console<M extends string>(config?: Tracer.LoggerConfig<M>): Tracer.Logger<M>;
+/**
+ * DailyLog will output all types log to diff files every day like log4j.
+ * @param config Configurate how logs are printed & how log files are saved.
+ */
+export function dailyfile<M extends string>(config?: Tracer.LoggerConfig<M> & Tracer.DailyFileConfig): Tracer.Logger<M>;
+
+/**
+ * End all the output.
+ *
+ * Equivalent to: `tracer.setLevel(Number.MAX_VALUE)`.
+ */
+export function close(): void;
+/**
+ * Change the log level in run time, for all the output.
+ * 
+ * Notice: If you set level in initialize, you can't change more lower level than the initial level.
+ * @param level Output the log, if level of log larger than or equal to `level`.
+ */
+export function setLevel(level: number | string): void;
+/**
+ * Get the current log level.
+ */
+export function getLevel(): number | string;