ee-core 2.1.0 → 2.1.1-beta.2

package/utils/depd/lib/browser/index.js

@@ -1,77 +1,77 @@
-/*!
- * depd
- * Copyright(c) 2015 Douglas Christopher Wilson
- * MIT Licensed
- */
-
-'use strict'
-
-/**
- * Module exports.
- * @public
- */
-
-module.exports = depd
-
-/**
- * Create deprecate for namespace in caller.
- */
-
-function depd (namespace) {
-  if (!namespace) {
-    throw new TypeError('argument namespace is required')
-  }
-
-  function deprecate (message) {
-    // no-op in browser
-  }
-
-  deprecate._file = undefined
-  deprecate._ignored = true
-  deprecate._namespace = namespace
-  deprecate._traced = false
-  deprecate._warned = Object.create(null)
-
-  deprecate.function = wrapfunction
-  deprecate.property = wrapproperty
-
-  return deprecate
-}
-
-/**
- * Return a wrapped function in a deprecation message.
- *
- * This is a no-op version of the wrapper, which does nothing but call
- * validation.
- */
-
-function wrapfunction (fn, message) {
-  if (typeof fn !== 'function') {
-    throw new TypeError('argument fn must be a function')
-  }
-
-  return fn
-}
-
-/**
- * Wrap property in a deprecation message.
- *
- * This is a no-op version of the wrapper, which does nothing but call
- * validation.
- */
-
-function wrapproperty (obj, prop, message) {
-  if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
-    throw new TypeError('argument obj must be object')
-  }
-
-  var descriptor = Object.getOwnPropertyDescriptor(obj, prop)
-
-  if (!descriptor) {
-    throw new TypeError('must call property on owner object')
-  }
-
-  if (!descriptor.configurable) {
-    throw new TypeError('property must be configurable')
-  }
-}
+/*!
+ * depd
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict'
+
+/**
+ * Module exports.
+ * @public
+ */
+
+module.exports = depd
+
+/**
+ * Create deprecate for namespace in caller.
+ */
+
+function depd (namespace) {
+  if (!namespace) {
+    throw new TypeError('argument namespace is required')
+  }
+
+  function deprecate (message) {
+    // no-op in browser
+  }
+
+  deprecate._file = undefined
+  deprecate._ignored = true
+  deprecate._namespace = namespace
+  deprecate._traced = false
+  deprecate._warned = Object.create(null)
+
+  deprecate.function = wrapfunction
+  deprecate.property = wrapproperty
+
+  return deprecate
+}
+
+/**
+ * Return a wrapped function in a deprecation message.
+ *
+ * This is a no-op version of the wrapper, which does nothing but call
+ * validation.
+ */
+
+function wrapfunction (fn, message) {
+  if (typeof fn !== 'function') {
+    throw new TypeError('argument fn must be a function')
+  }
+
+  return fn
+}
+
+/**
+ * Wrap property in a deprecation message.
+ *
+ * This is a no-op version of the wrapper, which does nothing but call
+ * validation.
+ */
+
+function wrapproperty (obj, prop, message) {
+  if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    throw new TypeError('argument obj must be object')
+  }
+
+  var descriptor = Object.getOwnPropertyDescriptor(obj, prop)
+
+  if (!descriptor) {
+    throw new TypeError('must call property on owner object')
+  }
+
+  if (!descriptor.configurable) {
+    throw new TypeError('property must be configurable')
+  }
+}

package/utils/get-port/index.d.ts

@@ -1,64 +1,64 @@
-/// <reference types="node"/>
-import {ListenOptions} from 'net';
-
-declare namespace getPort {
-	interface Options extends Omit<ListenOptions, 'port'> {
-		/**
-		A preferred port or an iterable of preferred ports to use.
-		*/
-		readonly port?: number | Iterable<number>;
-
-		/**
-		The host on which port resolution should be performed. Can be either an IPv4 or IPv6 address.
-		*/
-		readonly host?: string;
-	}
-}
-
-declare const getPort: {
-	/**
-	Get an available TCP port number.
-
-	@returns Port number.
-
-	@example
-	```
-	import getPort = require('get-port');
-
-	(async () => {
-		console.log(await getPort());
-		//=> 51402
-
-		// Pass in a preferred port
-		console.log(await getPort({port: 3000}));
-		// Will use 3000 if available, otherwise fall back to a random port
-
-		// Pass in an array of preferred ports
-		console.log(await getPort({port: [3000, 3001, 3002]}));
-		// Will use any element in the preferred ports array if available, otherwise fall back to a random port
-	})();
-	```
-	*/
-	(options?: getPort.Options): Promise<number>;
-
-	/**
-	Make a range of ports `from`...`to`.
-
-	@param from - First port of the range. Must be in the range `1024`...`65535`.
-	@param to - Last port of the range. Must be in the range `1024`...`65535` and must be greater than `from`.
-	@returns The ports in the range.
-
-	@example
-	```
-	import getPort = require('get-port');
-
-	(async () => {
-		console.log(await getPort({port: getPort.makeRange(3000, 3100)}));
-		// Will use any port from 3000 to 3100, otherwise fall back to a random port
-	})();
-	```
-	*/
-	makeRange(from: number, to: number): Iterable<number>;
-};
-
-export = getPort;
+/// <reference types="node"/>
+import {ListenOptions} from 'net';
+
+declare namespace getPort {
+	interface Options extends Omit<ListenOptions, 'port'> {
+		/**
+		A preferred port or an iterable of preferred ports to use.
+		*/
+		readonly port?: number | Iterable<number>;
+
+		/**
+		The host on which port resolution should be performed. Can be either an IPv4 or IPv6 address.
+		*/
+		readonly host?: string;
+	}
+}
+
+declare const getPort: {
+	/**
+	Get an available TCP port number.
+
+	@returns Port number.
+
+	@example
+	```
+	import getPort = require('get-port');
+
+	(async () => {
+		console.log(await getPort());
+		//=> 51402
+
+		// Pass in a preferred port
+		console.log(await getPort({port: 3000}));
+		// Will use 3000 if available, otherwise fall back to a random port
+
+		// Pass in an array of preferred ports
+		console.log(await getPort({port: [3000, 3001, 3002]}));
+		// Will use any element in the preferred ports array if available, otherwise fall back to a random port
+	})();
+	```
+	*/
+	(options?: getPort.Options): Promise<number>;
+
+	/**
+	Make a range of ports `from`...`to`.
+
+	@param from - First port of the range. Must be in the range `1024`...`65535`.
+	@param to - Last port of the range. Must be in the range `1024`...`65535` and must be greater than `from`.
+	@returns The ports in the range.
+
+	@example
+	```
+	import getPort = require('get-port');
+
+	(async () => {
+		console.log(await getPort({port: getPort.makeRange(3000, 3100)}));
+		// Will use any port from 3000 to 3100, otherwise fall back to a random port
+	})();
+	```
+	*/
+	makeRange(from: number, to: number): Iterable<number>;
+};
+
+export = getPort;

package/utils/get-port/index.js

@@ -1,109 +1,109 @@
-'use strict';
-const net = require('net');
-
-class Locked extends Error {
-	constructor(port) {
-		super(`${port} is locked`);
-	}
-}
-
-const lockedPorts = {
-	old: new Set(),
-	young: new Set()
-};
-
-// On this interval, the old locked ports are discarded,
-// the young locked ports are moved to old locked ports,
-// and a new young set for locked ports are created.
-const releaseOldLockedPortsIntervalMs = 1000 * 15;
-
-// Lazily create interval on first use
-let interval;
-
-const getAvailablePort = options => new Promise((resolve, reject) => {
-	const server = net.createServer();
-	server.unref();
-	server.on('error', reject);
-	server.listen(options, () => {
-		const {port} = server.address();
-		server.close(() => {
-			resolve(port);
-		});
-	});
-});
-
-const portCheckSequence = function * (ports) {
-	if (ports) {
-		yield * ports;
-	}
-
-	yield 0; // Fall back to 0 if anything else failed
-};
-
-module.exports = async options => {
-	let ports;
-
-	if (options) {
-		ports = typeof options.port === 'number' ? [options.port] : options.port;
-	}
-
-	if (interval === undefined) {
-		interval = setInterval(() => {
-			lockedPorts.old = lockedPorts.young;
-			lockedPorts.young = new Set();
-		}, releaseOldLockedPortsIntervalMs);
-
-		// Does not exist in some environments (Electron, Jest jsdom env, browser, etc).
-		if (interval.unref) {
-			interval.unref();
-		}
-	}
-
-	for (const port of portCheckSequence(ports)) {
-		try {
-			let availablePort = await getAvailablePort({...options, port}); // eslint-disable-line no-await-in-loop
-			while (lockedPorts.old.has(availablePort) || lockedPorts.young.has(availablePort)) {
-				if (port !== 0) {
-					throw new Locked(port);
-				}
-
-				availablePort = await getAvailablePort({...options, port}); // eslint-disable-line no-await-in-loop
-			}
-
-			lockedPorts.young.add(availablePort);
-			return availablePort;
-		} catch (error) {
-			if (!['EADDRINUSE', 'EACCES'].includes(error.code) && !(error instanceof Locked)) {
-				throw error;
-			}
-		}
-	}
-
-	throw new Error('No available ports found');
-};
-
-module.exports.makeRange = (from, to) => {
-	if (!Number.isInteger(from) || !Number.isInteger(to)) {
-		throw new TypeError('`from` and `to` must be integer numbers');
-	}
-
-	if (from < 1024 || from > 65535) {
-		throw new RangeError('`from` must be between 1024 and 65535');
-	}
-
-	if (to < 1024 || to > 65536) {
-		throw new RangeError('`to` must be between 1024 and 65536');
-	}
-
-	if (to < from) {
-		throw new RangeError('`to` must be greater than or equal to `from`');
-	}
-
-	const generator = function * (from, to) {
-		for (let port = from; port <= to; port++) {
-			yield port;
-		}
-	};
-
-	return generator(from, to);
-};
+'use strict';
+const net = require('net');
+
+class Locked extends Error {
+	constructor(port) {
+		super(`${port} is locked`);
+	}
+}
+
+const lockedPorts = {
+	old: new Set(),
+	young: new Set()
+};
+
+// On this interval, the old locked ports are discarded,
+// the young locked ports are moved to old locked ports,
+// and a new young set for locked ports are created.
+const releaseOldLockedPortsIntervalMs = 1000 * 15;
+
+// Lazily create interval on first use
+let interval;
+
+const getAvailablePort = options => new Promise((resolve, reject) => {
+	const server = net.createServer();
+	server.unref();
+	server.on('error', reject);
+	server.listen(options, () => {
+		const {port} = server.address();
+		server.close(() => {
+			resolve(port);
+		});
+	});
+});
+
+const portCheckSequence = function * (ports) {
+	if (ports) {
+		yield * ports;
+	}
+
+	yield 0; // Fall back to 0 if anything else failed
+};
+
+module.exports = async options => {
+	let ports;
+
+	if (options) {
+		ports = typeof options.port === 'number' ? [options.port] : options.port;
+	}
+
+	if (interval === undefined) {
+		interval = setInterval(() => {
+			lockedPorts.old = lockedPorts.young;
+			lockedPorts.young = new Set();
+		}, releaseOldLockedPortsIntervalMs);
+
+		// Does not exist in some environments (Electron, Jest jsdom env, browser, etc).
+		if (interval.unref) {
+			interval.unref();
+		}
+	}
+
+	for (const port of portCheckSequence(ports)) {
+		try {
+			let availablePort = await getAvailablePort({...options, port}); // eslint-disable-line no-await-in-loop
+			while (lockedPorts.old.has(availablePort) || lockedPorts.young.has(availablePort)) {
+				if (port !== 0) {
+					throw new Locked(port);
+				}
+
+				availablePort = await getAvailablePort({...options, port}); // eslint-disable-line no-await-in-loop
+			}
+
+			lockedPorts.young.add(availablePort);
+			return availablePort;
+		} catch (error) {
+			if (!['EADDRINUSE', 'EACCES'].includes(error.code) && !(error instanceof Locked)) {
+				throw error;
+			}
+		}
+	}
+
+	throw new Error('No available ports found');
+};
+
+module.exports.makeRange = (from, to) => {
+	if (!Number.isInteger(from) || !Number.isInteger(to)) {
+		throw new TypeError('`from` and `to` must be integer numbers');
+	}
+
+	if (from < 1024 || from > 65535) {
+		throw new RangeError('`from` must be between 1024 and 65535');
+	}
+
+	if (to < 1024 || to > 65536) {
+		throw new RangeError('`to` must be between 1024 and 65536');
+	}
+
+	if (to < from) {
+		throw new RangeError('`to` must be greater than or equal to `from`');
+	}
+
+	const generator = function * (from, to) {
+		for (let port = from; port <= to; port++) {
+			yield port;
+		}
+	};
+
+	return generator(from, to);
+};

package/utils/index.js

@@ -3,9 +3,26 @@
 const os = require("os");
 const path = require('path');
 const fs = require('fs');
+const { exec, execSync } = require('child_process');
+const { createHash } = require('crypto');
 const Ps = require('../ps');
 const UtilsJson = require('./json');
 
+// machine id
+const { platform } = process;
+const win32RegBinPath = {
+  native: '%windir%\\System32',
+  mixed: '%windir%\\sysnative\\cmd.exe /c %windir%\\System32'
+};
+const MachineGuid = {
+  darwin: 'ioreg -rd1 -c IOPlatformExpertDevice',
+  win32: `${win32RegBinPath[isWindowsProcessMixedOrNativeArchitecture()]}\\REG.exe ` +
+      'QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography ' +
+      '/v MachineGuid',
+  linux: '( cat /var/lib/dbus/machine-id /etc/machine-id 2> /dev/null || hostname ) | head -n 1 || :',
+  freebsd: 'kenv -q smbios.system.uuid || sysctl -n kern.hostuuid'
+};
+
 /**
  * 获取项目根目录package.json
  */
@@ -69,4 +86,75 @@ exports.isEncrypt = function(basePath) {
   return false;
 }
 
+/**
+ * get machine id
+ */
+exports.machineIdSync = function(original) {
+  let id = expose(execSync(MachineGuid[platform]).toString());
+  return original ? id : hash(id);
+}
+
+/**
+ * get machine id (promise)
+ * original <Boolean>, If true return original value of machine id, otherwise return hashed value (sha-256), default: false
+ */
+exports.machineId = function(original) {
+  return new Promise((resolve, reject) => {
+    return exec(MachineGuid[platform], {}, (err, stdout, stderr) => {
+      if (err) {
+        return reject(
+            new Error(`Error while obtaining machine id: ${err.stack}`)
+        );
+      }
+      let id = expose(stdout.toString());
+      return resolve(original ? id : hash(id));
+    });
+  });
+}
+
+function isWindowsProcessMixedOrNativeArchitecture() {
+  // detect if the node binary is the same arch as the Windows OS.
+  // or if this is 32 bit node on 64 bit windows.
+  if(process.platform !== 'win32') {
+    return '';
+  }
+  if( process.arch === 'ia32' && process.env.hasOwnProperty('PROCESSOR_ARCHITEW6432') ) {
+    return 'mixed';
+  }
+  return 'native';
+}
+
+function hash(guid) {
+  return createHash('sha256').update(guid).digest('hex');
+}
+
+function expose(result) {
+  switch (platform) {
+    case 'darwin':
+      return result
+        .split('IOPlatformUUID')[1]
+        .split('\n')[0].replace(/\=|\s+|\"/ig, '')
+        .toLowerCase();
+    case 'win32':
+      return result
+        .toString()
+        .split('REG_SZ')[1]
+        .replace(/\r+|\n+|\s+/ig, '')
+        .toLowerCase();
+    case 'linux':
+      return result
+        .toString()
+        .replace(/\r+|\n+|\s+/ig, '')
+        .toLowerCase();
+    case 'freebsd':
+      return result
+        .toString()
+        .replace(/\r+|\n+|\s+/ig, '')
+        .toLowerCase();
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+
+