orionsoft-react-scripts
Version:
Orionsoft Configuration and scripts for Create React App.
320 lines (302 loc) • 10.6 kB
JavaScript
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
var RawSource = require("./RawSource");
var OriginalSource = require("./OriginalSource");
var SourceMapSource = require("./SourceMapSource");
var LineToLineMappedSource = require("./LineToLineMappedSource");
var path = require("path"); // TODO refactor
var ModuleBuildError = require("./ModuleBuildError");
var ModuleError = require("./ModuleError");
var ModuleWarning = require("./ModuleWarning");
function utf8BufferToString(buf) {
var str = buf.toString("utf-8");
if(str.charCodeAt(0) === 0xFEFF) {
return str.substr(1);
} else {
return str;
}
}
function NormalModuleMixin(loaders, resource) {
this.resource = resource;
this.loaders = loaders;
var resourcePath = this.splitQuery(this.resource)[0];
this.context = resourcePath ? path.dirname(resourcePath) : null;
this.fileDependencies = [];
this.contextDependencies = [];
this.warnings = [];
this.errors = [];
this.error = null;
this._source = null;
}
module.exports = NormalModuleMixin;
NormalModuleMixin.mixin = function(pt) {
for(var name in NormalModuleMixin.prototype)
pt[name] = NormalModuleMixin.prototype[name];
};
NormalModuleMixin.prototype.splitQuery = function splitQuery(req) {
var i = req.indexOf("?");
if(i < 0) return [req, ""];
return [req.substr(0, i), req.substr(i)];
};
NormalModuleMixin.prototype.doBuild = function doBuild(options, moduleContext, resolver, fs, callback) {
var splitQuery = this.splitQuery.bind(this);
var module = this;
this.cacheable = true;
// Prepare context
var loaders = [];
function addLoaderToList(loader) {
var l = splitQuery(loader);
loaders.push({
request: loader,
path: l[0],
query: l[1],
module: null
});
}
this.loaders.forEach(addLoaderToList);
var loaderContextCacheable;
var loaderContext = {
version: 1,
context: this.context,
loaders: loaders,
loaderIndex: 0,
resource: this.resource,
resourcePath: splitQuery(this.resource)[0],
resourceQuery: this.resource ? splitQuery(this.resource)[1] || null : undefined,
emitWarning: function(warning) {
this.warnings.push(new ModuleWarning(this, warning));
}.bind(this),
emitError: function(error) {
this.errors.push(new ModuleError(this, error));
}.bind(this),
exec: function(code, filename) {
if(typeof __webpack_modules__ === "undefined") {
// TODO: check if in enhanced-require
var Module = require("module");
var m = new Module(filename, module);
m.paths = Module._nodeModulePaths(loaderContext.context);
m.filename = filename;
m._compile(code, filename);
return m.exports;
} else {
throw new Error("loaderContext.exec is not supported");
}
},
resolve: function(context, request, callback) {
resolver.resolve(context, request, callback);
},
resolveSync: function(context, request) {
return resolver.resolveSync(context, request);
},
cacheable: function(flag) {
loaderContextCacheable = flag !== false;
},
dependency: function(file) {
this.fileDependencies.push(file);
}.bind(this),
addDependency: function(file) {
this.fileDependencies.push(file);
}.bind(this),
addContextDependency: function(context) {
this.contextDependencies.push(context);
}.bind(this),
clearDependencies: function() {
this.fileDependencies.length = 0;
this.contextDependencies.length = 0;
module.cacheable = true;
}.bind(this),
inputValue: undefined,
value: null,
options: options,
debug: options.debug
};
this.fillLoaderContext(loaderContext, options, moduleContext);
if(options.loader) for(var key in options.loader)
loaderContext[key] = options.loader[key];
function runSyncOrAsync(fn, context, args, callback) {
var isSync = true;
var isDone = false;
var isError = false; // internal error
var reportedError = false;
if(!context.async) context.async = function async() {
if(isDone) {
if(reportedError) return; // ignore
throw new Error("async(): The callback was already called.");
}
isSync = false;
return context.callback;
};
context.callback = function() {
if(isDone) {
if(reportedError) return; // ignore
throw new Error("callback(): The callback was already called.");
}
isDone = true;
isSync = false;
try {
callback.apply(null, arguments);
} catch(e) {
isError = true;
throw e;
}
};
try {
var result = (function WEBPACK_CORE_LOADER_EXECUTION() { return fn.apply(context, args) }());
if(isSync) {
isDone = true;
if(result === undefined)
return callback();
return callback(null, result);
}
} catch(e) {
if(isError) throw e;
if(isDone) {
// loader is already "done", so we cannot use the callback function
// for better debugging we print the error on the console
if(typeof e === "object" && e.stack) console.error(e.stack);
else console.error(e);
return;
}
isDone = true;
reportedError = true;
callback(e);
}
}
// Load and pitch loaders
(function loadPitch() {
var l = loaderContext.loaders[loaderContext.loaderIndex];
if(!l) {
return onLoadPitchDone.call(this);
}
if(l.module) {
loaderContext.loaderIndex++;
return loadPitch.call(this);
}
if(typeof __webpack_modules__ === "undefined") {
if(require.supportQuery) {
l.module = require(l.request);
} else {
try {
l.module = require(l.path);
} catch (e) {
// it is possible for node to choke on a require if the FD descriptor
// limit has been reached. give it a chance to recover.
if (e instanceof Error && e.code === 'EMFILE') {
if (typeof setImmediate === 'function') {
// node >= 0.9.0
return setImmediate(loadPitch.bind(this));
} else {
// node < 0.9.0
return process.nextTick(loadPitch.bind(this));
}
}
return callback(e)
}
}
} else if(typeof __webpack_require_loader__ === "function") {
l.module = __webpack_require_loader__(l.request);
} else {
return callback(new Error("Cannot load loader, __webpack_require_loader__ not provided."));
}
if(typeof l.module !== "function")
return callback(new Error("Loader " + l.request + " didn't return a function"));
var pitchedLoaders = [];
var remaining = [];
for(var i = 0; i < loaderContext.loaderIndex; i++)
pitchedLoaders.push(loaderContext.loaders[i].request);
for(i = loaderContext.loaderIndex + 1; i < loaderContext.loaders.length; i++)
remaining.push(loaderContext.loaders[i].request);
remaining.push(loaderContext.resource);
if(typeof l.module.pitch !== "function") return loadPitch.call(this);
loaderContextCacheable = false;
var privateLoaderContext = Object.create(loaderContext);
privateLoaderContext.query = l.query;
runSyncOrAsync(l.module.pitch, privateLoaderContext, [remaining.join("!"), pitchedLoaders.join("!"), l.data = {}], function(err) {
if(err) return onModuleBuildFailed.call(this, err);
if(!loaderContextCacheable) this.cacheable = false;
var args = Array.prototype.slice.call(arguments, 1);
loaderContext.resourcePath = privateLoaderContext.resourcePath;
loaderContext.resourceQuery = privateLoaderContext.resourceQuery;
loaderContext.resource = privateLoaderContext.resource;
loaderContext.loaderIndex = privateLoaderContext.loaderIndex;
if(args.length > 0) {
nextLoader.apply(this, [null].concat(args));
} else {
loadPitch.call(this);
}
}.bind(this));
}.call(this));
var resourceBuffer;
function onLoadPitchDone() {
loaderContext.loaderIndex = loaderContext.loaders.length;
var request = [];
for(var i = 0; i < loaderContext.loaders.length; i++)
request.push(loaderContext.loaders[i].request);
request.push(loaderContext.resource);
loaderContext.request = request.join("!");
var resourcePath = loaderContext.resourcePath;
loaderContextCacheable = true;
if(resourcePath) {
loaderContext.addDependency(resourcePath);
fs.readFile(resourcePath, function(err, buffer) {
if(err) return nextLoader(err);
if(module.lineToLine)
resourceBuffer = buffer;
nextLoader(null, buffer);
});
} else
nextLoader(null, null);
}
function nextLoader(err/*, paramBuffer1, param2, ...*/) {
if(!loaderContextCacheable) module.cacheable = false;
var args = Array.prototype.slice.call(arguments, 1);
if(err) {
// a loader emitted an error
return onModuleBuildFailed.call(module, err);
}
if(loaderContext.loaderIndex === 0) {
if(Buffer.isBuffer(args[0]))
args[0] = utf8BufferToString(args[0]);
return onModuleBuild.apply(module, args);
}
loaderContext.loaderIndex--;
var l = loaderContext.loaders[loaderContext.loaderIndex];
if(!l.module) return nextLoader.apply(null, [null].concat(args));
var privateLoaderContext = Object.create(loaderContext);
privateLoaderContext.data = l.data;
privateLoaderContext.inputValue = loaderContext.inputValue;
privateLoaderContext.query = l.query;
if(!l.module.raw && Buffer.isBuffer(args[0])) {
args[0] = utf8BufferToString(args[0]);
} else if(l.module.raw && typeof args[0] === "string") {
args[0] = new Buffer(args[0], "utf-8");
}
loaderContextCacheable = false;
runSyncOrAsync(l.module, privateLoaderContext, args, function() {
loaderContext.inputValue = privateLoaderContext.value;
nextLoader.apply(null, arguments);
});
}
function onModuleBuild(source, sourceMap) {
if(!Buffer.isBuffer(source) && typeof source !== "string")
return onModuleBuildFailed.call(this, new Error("Final loader didn't return a Buffer or String"));
if(this.identifier && this.lineToLine && resourceBuffer) {
this._source = new LineToLineMappedSource(source, this.identifier(),
resourceBuffer.toString("utf-8"));
} else if(this.identifier && this.useSourceMap && sourceMap) {
this._source = new SourceMapSource(source, this.identifier(), sourceMap);
} else if(this.identifier) {
this._source = new OriginalSource(source, this.identifier());
} else {
this._source = new RawSource(source);
}
return callback();
}
function onModuleBuildFailed(err) {
this.error = err;
return callback(new ModuleBuildError(this, err));
}
};
NormalModuleMixin.prototype.fillLoaderContext = function fillLoaderContext() {};