feat(node): node 12 compatible util module and improved console

.eslintrc

@@ -5,18 +5,18 @@
     "sourceType": "script"
   },
   "globals": {
-    "Ti": false,
-    "Titanium": false,
-    "__filename": false,
-    "__dirname": false,
-    "kroll": false
+    "Ti": "readonly",
+    "Titanium": "readonly",
+    "__filename": "readonly",
+    "__dirname": "readonly",
+    "kroll": "readonly"
   },
   "rules": {
     "strict": ["error", "global"]
   },
   "overrides": [
     {
-      "files": [ "tests/Resources/es6.*.js" ],
+      "files": [ "tests/Resources/es6.*.js", "tests/Resources/util.test.js" ],
       "parserOptions": {
         "ecmaVersion": 2017,
         "sourceType": "module"
@@ -46,7 +46,7 @@
     {
       "files": [ "common/Resources/**/*.js" ],
       "parserOptions": {
-        "ecmaVersion": 2017,
+        "ecmaVersion": 2018,
         "sourceType": "module"
       },
       "rules": {

common/Resources/ti.internal/extensions/js/console.js

@@ -0,0 +1,30 @@
+import { formatWithOptions } from '../node/internal/util/inspect';
+
+const nativeDebug = console.debug;
+const nativeError = console.error;
+const nativeInfo = console.info;
+const nativeLog = console.log;
+const nativeWarn = console.warn;
+
+const kColorInspectOptions = { colors: true };
+const kNoColorInspectOptions = {};
+
+console.debug = function (...args) {
+	nativeDebug.call(console, formatWithOptions(kColorInspectOptions, ...args));
+};
+
+console.error = function (...args) {
+	nativeError.call(console, formatWithOptions(kNoColorInspectOptions, ...args));
+};
+
+console.info = function (...args) {
+	nativeInfo.call(console, formatWithOptions(kColorInspectOptions, ...args));
+};
+
+console.log = function (...args) {
+	nativeLog.call(console, formatWithOptions(kColorInspectOptions, ...args));
+};
+
+console.warn = function (...args) {
+	nativeWarn.call(console, formatWithOptions(kNoColorInspectOptions, ...args));
+};

common/Resources/ti.internal/extensions/js/index.js

@@ -1,2 +1,3 @@
 // Load all JavaScript extensions/polyfills
+import './console';
 import './Error';

common/Resources/ti.internal/extensions/node/assert.js

@@ -299,8 +299,8 @@ function deepEqual(actual, expected, strictness, references) {
 	}
 
 	let comparison = COMPARE_TYPE.Object;
-	if (util.types.isRegexp(actual)) { // RegExp source and flags should match
-		if (!util.types.isRegexp(expected) || actual.flags !== expected.flags || actual.source !== expected.source) {
+	if (util.types.isRegExp(actual)) { // RegExp source and flags should match
+		if (!util.types.isRegExp(expected) || actual.flags !== expected.flags || actual.source !== expected.source) {
 			return false;
 		}
 		// continue on to check properties...
@@ -624,7 +624,7 @@ function checkError(actual, expected, message) {
 	// Error type - check type matches
 	// Error instance - compare properties
 	if (typeof expected === 'object') {
-		if (util.types.isRegexp(expected)) {
+		if (util.types.isRegExp(expected)) {
 			return expected.test(actual); // does the error match the RegExp expression? if so, pass
 		}
 

common/Resources/ti.internal/extensions/node/buffer.js

@@ -14,7 +14,17 @@
  * a Uint8Array in any of our APIs that take a Ti.Buffer and eventually deprecating/removing Ti.Buffer.
  */
 
-import { isInsideNodeModules } from './internal/util';
+import {
+	customInspectSymbol,
+	getOwnNonIndexProperties,
+	isBuffer,
+	isInsideNodeModules,
+	propertyFilter
+} from './internal/util';
+
+import { inspect as utilInspect } from './internal/util/inspect';
+
+const { ALL_PROPERTIES, ONLY_ENUMERABLE } = propertyFilter;
 
 // https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings
 const TI_CODEC_MAP = new Map();
@@ -51,6 +61,8 @@ const uint8DoubleArray = new Uint8Array(doubleArray.buffer);
 const floatArray = new Float32Array(1);
 const uint8FloatArray = new Uint8Array(floatArray.buffer);
 
+let INSPECT_MAX_BYTES = 50;
+
 class Buffer {
 	/**
 	 * Constructs a new buffer.
@@ -80,17 +92,23 @@ class Buffer {
 
 		const tiBuffer = arg;
 		let start = encodingOrOffset;
-		this._tiBuffer = tiBuffer;
 		if (start === undefined) {
 			start = 0;
 		}
-		this.byteOffset = start;
 		if (length === undefined) {
-			this.length = tiBuffer.length - this.byteOffset;
-		} else {
-			this.length = length;
+			length = tiBuffer.length - start;
 		}
-		this._isBuffer = true;
+		Object.defineProperties(this, {
+			byteOffset: {
+				value: start
+			},
+			length: {
+				value: length
+			},
+			_tiBuffer: {
+				value: tiBuffer
+			}
+		});
 		// FIXME: Support .buffer property that holds an ArrayBuffer!
 	}
 
@@ -1405,10 +1423,46 @@ class Buffer {
 	 * @returns {boolean}
 	 */
 	static isBuffer(obj) {
-		return obj !== null && obj !== undefined && obj._isBuffer === true;
+		return obj !== null && obj !== undefined && obj[isBuffer] === true;
+	}
+
+	// Override how buffers are presented by util.inspect().
+	[customInspectSymbol](recurseTimes, ctx) {
+		const max = INSPECT_MAX_BYTES;
+		const actualMax = Math.min(max, this.length);
+		const remaining = this.length - max;
+		let str = this.slice(0, actualMax).toString('hex').replace(/(.{2})/g, '$1 ').trim();
+		if (remaining > 0) {
+			str += ` ... ${remaining} more byte${remaining > 1 ? 's' : ''}`;
+		}
+		// Inspect special properties as well, if possible.
+		if (ctx) {
+			let extras = false;
+			const filter = ctx.showHidden ? ALL_PROPERTIES : ONLY_ENUMERABLE;
+			const obj = getOwnNonIndexProperties(this, filter).reduce((obj, key) => {
+				extras = true;
+				obj[key] = this[key];
+				return obj;
+			}, Object.create(null));
+			if (extras) {
+				if (this.length !== 0) {
+					str += ', ';
+				}
+				// '[Object: null prototype] {'.length === 26
+				// This is guarded with a test.
+				str += utilInspect(obj, {
+					...ctx,
+					breakLength: Infinity,
+					compact: true
+				}).slice(27, -2);
+			}
+		}
+		return `<${this.constructor.name} ${str}>`;
 	}
 }
 
+Buffer.prototype.inspect = Buffer.prototype[customInspectSymbol];
+
 Buffer.poolSize = 8192;
 
 export default {
@@ -1543,6 +1597,8 @@ const arrayIndexHandler = {
 			if (Number.isSafeInteger(num)) {
 				return getAdjustedIndex(target, num);
 			}
+		} else if (propKey === isBuffer) {
+			return true;
 		}
 		return Reflect.get(target, propKey, receiver);
 	},
@@ -1589,7 +1645,7 @@ function setAdjustedIndex(buf, index, value) {
  * @returns {Buffer} wrapped inside a Proxy
  */
 function newBuffer(...args) {
-	return new Proxy(new Buffer(...args), arrayIndexHandler);  // eslint-disable-line security/detect-new-buffer
+	return new Proxy(new Buffer(...args), arrayIndexHandler); // eslint-disable-line security/detect-new-buffer
 }
 
 /**

common/Resources/ti.internal/extensions/node/internal/assert.js

@@ -0,0 +1,26 @@
+import { codes } from './errors';
+
+let error;
+function lazyError() {
+	if (!error) {
+		// @fixme rollup cannot handle lazy loaded modules, maybe move to webpack?
+		// error = require('./errors').codes.ERR_INTERNAL_ASSERTION;
+		error = codes.ERR_INTERNAL_ASSERTION;
+	}
+	return error;
+}
+function assert(value, message) {
+	if (!value) {
+		const ERR_INTERNAL_ASSERTION = lazyError();
+		throw new ERR_INTERNAL_ASSERTION(message);
+	}
+}
+
+function fail(message) {
+	const ERR_INTERNAL_ASSERTION = lazyError();
+	throw new ERR_INTERNAL_ASSERTION(message);
+}
+
+assert.fail = fail;
+
+export default assert;