control-freak-ide/server/nodejs/dojo/node.js

define([
	"dojo/_base/kernel",
	"dojo/has",
	"require",
	"dojo/noob" //empty module
], function (kernel, has, require, noob) {

	var nodeRequire = kernel.global.require && kernel.global.require.nodeRequire;
	var _window = typeof window !== 'undefined' ? window : null;
	var isElectron = _window && _window.process && _window.process.type === "renderer";
	var module = nodeRequire ? nodeRequire("module") : null;
	if (!nodeRequire) {
		//@TODO: notice that window.nodeRequire must be set manually in your Electron renderer code. I could not extract the
		//Electron's require from anywhere.
		if (isElectron && _window && _window.nodeRequire) {
			nodeRequire = _window.nodeRequire;
			module = nodeRequire("module");
		} else {
			if (has('debug')) {
				console.warn("Cannot get Electron/Node.js require, will noob to empty module dojo/noob");
			}
		}
	}
	var _load = function (id, contextRequire, load, from) {
		/*global define:true */
		// The `nodeRequire` function comes from the Node.js module of the AMD loader, so module ID resolution is
		// relative to the loader's path, not the calling AMD module's path. This means that loading Node.js
		// modules that exist in a higher level or sibling path to the loader will cause those modules to fail to
		// resolve.
		//
		// Node.js does not expose a public API for performing module filename resolution relative to an arbitrary
		// directory root, so we are forced to dig into the internal functions of the Node.js `module` module to
		// use Node.js's own path resolution code instead of having to duplicate its rules ourselves.
		//
		// Sooner or later, probably around the time that Node.js internal code is reworked to use ES6, these
		// methods will no longer be exposed and we will have to find another workaround if they have not exposed
		// an API for doing this by then.
		if (module && module._findPath && module._nodeModulePaths) {
			// var localModulePath = module._findPath(id, module._nodeModulePaths(contextRequire.toUrl(".")));
			var localModulePath = module._findPath(id, module._nodeModulePaths(from));
			if (localModulePath !== false) {
				id = localModulePath;
			}
		}

		if (id && typeof global !== "undefined" && global.moduleCache && global.moduleCache[id]) {
			return global.moduleCache[id];
		}

		//noob out modules when not node-js and not electron
		if (!module) {
			return load(noob);
		}

		var oldDefine = define,
			result;

		// Some modules attempt to detect an AMD loader by looking for global AMD `define`. This causes issues
		// when other CommonJS modules attempt to load them via the standard Node.js `require`, so hide it
		// during the load
		define = undefined;

		try {
			result = nodeRequire(id);
		} finally {
			define = oldDefine;
		}

		// load(result);
		return result;
	}
	return {
		// summary:
		//		This AMD plugin module allows native Node.js modules to be loaded by AMD modules using the Dojo
		//		loader. This plugin will not work with AMD loaders that do not expose the Node.js require function
		//		at `require.nodeRequire`.
		//
		// example:
		//	|	require(["dojo/node!fs"], function(fs){
		//	|		var fileData = fs.readFileSync("foo.txt", "utf-8");
		//	|	});
		load: function (id, contextRequire, load) {

			var result = _load(id, contextRequire, load, process.cwd());
			if (!result) {
				result = _load(id, contextRequire, load, contextRequire.toUrl("."));
			}
			load(result);
			/*
			// The `nodeRequire` function comes from the Node.js module of the AMD loader, so module ID resolution is
			// relative to the loader's path, not the calling AMD module's path. This means that loading Node.js
			// modules that exist in a higher level or sibling path to the loader will cause those modules to fail to
			// resolve.
			//
			// Node.js does not expose a public API for performing module filename resolution relative to an arbitrary
			// directory root, so we are forced to dig into the internal functions of the Node.js `module` module to
			// use Node.js's own path resolution code instead of having to duplicate its rules ourselves.
			//
			// Sooner or later, probably around the time that Node.js internal code is reworked to use ES6, these
			// methods will no longer be exposed and we will have to find another workaround if they have not exposed
			// an API for doing this by then.
			if (module && module._findPath && module._nodeModulePaths) {
				var from = has('cwd_patch') ? process.cwd() : contextRequire.toUrl(".");
				// var localModulePath = module._findPath(id, module._nodeModulePaths(contextRequire.toUrl(".")));
				var localModulePath = module._findPath(id, module._nodeModulePaths(from));
				if (localModulePath !== false) {
					id = localModulePath;
				}
			}

			if (id && typeof global !== "undefined" && global.moduleCache && global.moduleCache[id]) {
				return global.moduleCache[id];
			}

			//noob out modules when not node-js and not electron
			if (!module) {
				return load(noob);
			}

			var oldDefine = define,
				result;

			// Some modules attempt to detect an AMD loader by looking for global AMD `define`. This causes issues
			// when other CommonJS modules attempt to load them via the standard Node.js `require`, so hide it
			// during the load
			define = undefined;

			try {
				result = nodeRequire(id);
			} finally {
				define = oldDefine;
			}

			load(result);
			*/
		},
		normalize: function ( /**string*/ id, /*Function*/ normalize) {
			// summary:
			//		Produces a normalized CommonJS module ID to be used by Node.js `require`. Relative IDs
			//		are resolved relative to the requesting module's location in the filesystem and will
			//		return an ID with path separators appropriate for the local filesystem

			if (id.charAt(0) === ".") {
				// absolute module IDs need to be generated based on the AMD loader's knowledge of the parent module,
				// since Node.js will try to use the directory containing `dojo.js` as the relative root if a
				// relative module ID is provided
				id = require.toUrl(normalize("./" + id));
			}

			if (!module) {
				id = normalize('dojo/noob');
			}

			return id;
		}
	};
});