loader-runner
Version:
Runs (webpack) loaders
516 lines (465 loc) • 13.6 kB
JavaScript
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
;
const fs = require("fs");
const readFile = fs.readFile.bind(fs);
const loadLoader = require("./loadLoader");
function utf8BufferToString(buf) {
const str = buf.toString("utf8");
if (str.charCodeAt(0) === 0xfeff) {
return str.slice(1);
}
return str;
}
const PATH_QUERY_FRAGMENT_REGEXP =
/^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
const ZERO_ESCAPE_REGEXP = /\0(.)/g;
/**
* @param {string} identifier identifier
* @returns {[string, string, string]} parsed identifier
*/
function parseIdentifier(identifier) {
// Fast path for inputs that don't use \0 escaping.
const firstEscape = identifier.indexOf("\0");
if (firstEscape < 0) {
const queryStart = identifier.indexOf("?");
const fragmentStart = identifier.indexOf("#");
if (fragmentStart < 0) {
if (queryStart < 0) {
// No fragment, no query
return [identifier, "", ""];
}
// Query, no fragment
return [
identifier.slice(0, queryStart),
identifier.slice(queryStart),
"",
];
}
if (queryStart < 0 || fragmentStart < queryStart) {
// Fragment, no query
return [
identifier.slice(0, fragmentStart),
"",
identifier.slice(fragmentStart),
];
}
// Query and fragment
return [
identifier.slice(0, queryStart),
identifier.slice(queryStart, fragmentStart),
identifier.slice(fragmentStart),
];
}
const match = PATH_QUERY_FRAGMENT_REGEXP.exec(identifier);
return [
match[1].replace(ZERO_ESCAPE_REGEXP, "$1"),
match[2] ? match[2].replace(ZERO_ESCAPE_REGEXP, "$1") : "",
match[3] || "",
];
}
function dirname(path) {
if (path === "/") return "/";
const i = path.lastIndexOf("/");
const j = path.lastIndexOf("\\");
const i2 = path.indexOf("/");
const j2 = path.indexOf("\\");
const idx = i > j ? i : j;
const idx2 = i > j ? i2 : j2;
if (idx < 0) return path;
if (idx === idx2) return path.slice(0, idx + 1);
return path.slice(0, idx);
}
function createLoaderObject(loader) {
const obj = {
path: null,
query: null,
fragment: null,
options: null,
ident: null,
normal: null,
pitch: null,
raw: null,
data: null,
pitchExecuted: false,
normalExecuted: false,
};
Object.defineProperty(obj, "request", {
enumerable: true,
get() {
return (
obj.path.replace(/#/g, "\0#") +
obj.query.replace(/#/g, "\0#") +
obj.fragment
);
},
set(value) {
if (typeof value === "string") {
const [path, query, fragment] = parseIdentifier(value);
obj.path = path;
obj.query = query;
obj.fragment = fragment;
obj.options = undefined;
obj.ident = undefined;
} else {
if (!value.loader) {
throw new Error(
`request should be a string or object with loader and options (${JSON.stringify(
value
)})`
);
}
obj.path = value.loader;
obj.fragment = value.fragment || "";
obj.type = value.type;
obj.options = value.options;
obj.ident = value.ident;
if (obj.options === null) {
obj.query = "";
} else if (obj.options === undefined) {
obj.query = "";
} else if (typeof obj.options === "string") {
obj.query = `?${obj.options}`;
} else if (obj.ident) {
obj.query = `??${obj.ident}`;
} else if (typeof obj.options === "object" && obj.options.ident) {
obj.query = `??${obj.options.ident}`;
} else {
obj.query = `?${JSON.stringify(obj.options)}`;
}
}
},
});
obj.request = loader;
if (Object.preventExtensions) {
Object.preventExtensions(obj);
}
return obj;
}
function runSyncOrAsync(fn, context, args, callback) {
let isSync = true;
let isDone = false;
let isError = false; // internal error
let reportedError = false;
// eslint-disable-next-line func-name-matching
const innerCallback = (context.callback = function innerCallback() {
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 (err) {
isError = true;
throw err;
}
});
context.async = function async() {
if (isDone) {
if (reportedError) return; // ignore
throw new Error("async(): The callback was already called.");
}
isSync = false;
return innerCallback;
};
try {
const result = (function LOADER_EXECUTION() {
return fn.apply(context, args);
})();
if (isSync) {
isDone = true;
if (result === undefined) return callback();
if (
result &&
typeof result === "object" &&
typeof result.then === "function"
) {
return result.then((r) => {
callback(null, r);
}, callback);
}
return callback(null, result);
}
} catch (err) {
if (isError) throw err;
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 err === "object" && err.stack) {
// eslint-disable-next-line no-console
console.error(err.stack);
} else {
// eslint-disable-next-line no-console
console.error(err);
}
return;
}
isDone = true;
reportedError = true;
callback(err);
}
}
function convertArgs(args, raw) {
if (!raw && Buffer.isBuffer(args[0])) {
args[0] = utf8BufferToString(args[0]);
} else if (raw && typeof args[0] === "string") {
args[0] = Buffer.from(args[0], "utf8");
}
}
function iterateNormalLoaders(options, loaderContext, args, callback) {
if (loaderContext.loaderIndex < 0) return callback(null, args);
const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
// iterate
if (currentLoaderObject.normalExecuted) {
loaderContext.loaderIndex--;
return iterateNormalLoaders(options, loaderContext, args, callback);
}
const fn = currentLoaderObject.normal;
currentLoaderObject.normalExecuted = true;
if (!fn) {
return iterateNormalLoaders(options, loaderContext, args, callback);
}
convertArgs(args, currentLoaderObject.raw);
runSyncOrAsync(fn, loaderContext, args, function runSyncOrAsyncCallback(err) {
if (err) return callback(err);
const args = Array.prototype.slice.call(arguments, 1);
iterateNormalLoaders(options, loaderContext, args, callback);
});
}
function processResource(options, loaderContext, callback) {
// set loader index to last loader
loaderContext.loaderIndex = loaderContext.loaders.length - 1;
const { resourcePath } = loaderContext;
if (resourcePath) {
options.processResource(
loaderContext,
resourcePath,
function processResourceCallback(err) {
if (err) return callback(err);
const args = Array.prototype.slice.call(arguments, 1);
[options.resourceBuffer] = args;
iterateNormalLoaders(options, loaderContext, args, callback);
}
);
} else {
iterateNormalLoaders(options, loaderContext, [null], callback);
}
}
function iteratePitchingLoaders(options, loaderContext, callback) {
// abort after last loader
if (loaderContext.loaderIndex >= loaderContext.loaders.length) {
return processResource(options, loaderContext, callback);
}
const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
// iterate
if (currentLoaderObject.pitchExecuted) {
loaderContext.loaderIndex++;
return iteratePitchingLoaders(options, loaderContext, callback);
}
// load loader module
loadLoader(currentLoaderObject, (err) => {
if (err) {
loaderContext.cacheable(false);
return callback(err);
}
const fn = currentLoaderObject.pitch;
currentLoaderObject.pitchExecuted = true;
if (!fn) return iteratePitchingLoaders(options, loaderContext, callback);
runSyncOrAsync(
fn,
loaderContext,
[
loaderContext.remainingRequest,
loaderContext.previousRequest,
(currentLoaderObject.data = {}),
],
function runSyncOrAsyncCallback(err) {
if (err) return callback(err);
const args = Array.prototype.slice.call(arguments, 1);
// Determine whether to continue the pitching process based on
// argument values (as opposed to argument presence) in order
// to support synchronous and asynchronous usages.
const hasArg = args.some((value) => value !== undefined);
if (hasArg) {
loaderContext.loaderIndex--;
iterateNormalLoaders(options, loaderContext, args, callback);
} else {
iteratePitchingLoaders(options, loaderContext, callback);
}
}
);
});
}
module.exports.getContext = function getContext(resource) {
const [path] = parseIdentifier(resource);
return dirname(path);
};
module.exports.runLoaders = function runLoaders(options, callback) {
// read options
const resource = options.resource || "";
let loaders = options.loaders || [];
const loaderContext = options.context || {};
const processResource =
options.processResource ||
((readResource, context, resource, callback) => {
context.addDependency(resource);
readResource(resource, callback);
}).bind(null, options.readResource || readFile);
const splittedResource = resource && parseIdentifier(resource);
const resourcePath = splittedResource ? splittedResource[0] : "";
const resourceQuery = splittedResource ? splittedResource[1] : "";
const resourceFragment = splittedResource ? splittedResource[2] : "";
const contextDirectory = resourcePath ? dirname(resourcePath) : null;
// execution state
let requestCacheable = true;
const fileDependencies = [];
const contextDependencies = [];
const missingDependencies = [];
// prepare loader objects
loaders = loaders.map(createLoaderObject);
loaderContext.context = contextDirectory;
loaderContext.loaderIndex = 0;
loaderContext.loaders = loaders;
loaderContext.resourcePath = resourcePath;
loaderContext.resourceQuery = resourceQuery;
loaderContext.resourceFragment = resourceFragment;
loaderContext.async = null;
loaderContext.callback = null;
loaderContext.cacheable = function cacheable(flag) {
if (flag === false) {
requestCacheable = false;
}
};
loaderContext.dependency = loaderContext.addDependency =
function addDependency(file) {
fileDependencies.push(file);
};
loaderContext.addContextDependency = function addContextDependency(context) {
contextDependencies.push(context);
};
loaderContext.addMissingDependency = function addMissingDependency(context) {
missingDependencies.push(context);
};
loaderContext.getDependencies = function getDependencies() {
return [...fileDependencies];
};
loaderContext.getContextDependencies = function getContextDependencies() {
return [...contextDependencies];
};
loaderContext.getMissingDependencies = function getMissingDependencies() {
return [...missingDependencies];
};
loaderContext.clearDependencies = function clearDependencies() {
fileDependencies.length = 0;
contextDependencies.length = 0;
missingDependencies.length = 0;
requestCacheable = true;
};
Object.defineProperty(loaderContext, "resource", {
enumerable: true,
get() {
return (
loaderContext.resourcePath.replace(/#/g, "\0#") +
loaderContext.resourceQuery.replace(/#/g, "\0#") +
loaderContext.resourceFragment
);
},
set(value) {
const splittedResource = value && parseIdentifier(value);
loaderContext.resourcePath = splittedResource ? splittedResource[0] : "";
loaderContext.resourceQuery = splittedResource ? splittedResource[1] : "";
loaderContext.resourceFragment = splittedResource
? splittedResource[2]
: "";
},
});
Object.defineProperty(loaderContext, "request", {
enumerable: true,
get() {
return loaderContext.loaders
.map((loader) => loader.request)
.concat(loaderContext.resource || "")
.join("!");
},
});
Object.defineProperty(loaderContext, "remainingRequest", {
enumerable: true,
get() {
if (
loaderContext.loaderIndex >= loaderContext.loaders.length - 1 &&
!loaderContext.resource
) {
return "";
}
return loaderContext.loaders
.slice(loaderContext.loaderIndex + 1)
.map((loader) => loader.request)
.concat(loaderContext.resource || "")
.join("!");
},
});
Object.defineProperty(loaderContext, "currentRequest", {
enumerable: true,
get() {
return loaderContext.loaders
.slice(loaderContext.loaderIndex)
.map((loader) => loader.request)
.concat(loaderContext.resource || "")
.join("!");
},
});
Object.defineProperty(loaderContext, "previousRequest", {
enumerable: true,
get() {
return loaderContext.loaders
.slice(0, loaderContext.loaderIndex)
.map((loader) => loader.request)
.join("!");
},
});
Object.defineProperty(loaderContext, "query", {
enumerable: true,
get() {
const entry = loaderContext.loaders[loaderContext.loaderIndex];
return entry.options && typeof entry.options === "object"
? entry.options
: entry.query;
},
});
Object.defineProperty(loaderContext, "data", {
enumerable: true,
get() {
return loaderContext.loaders[loaderContext.loaderIndex].data;
},
});
// finish loader context
if (Object.preventExtensions) {
Object.preventExtensions(loaderContext);
}
const processOptions = {
resourceBuffer: null,
processResource,
};
iteratePitchingLoaders(processOptions, loaderContext, (err, result) => {
if (err) {
return callback(err, {
cacheable: requestCacheable,
fileDependencies,
contextDependencies,
missingDependencies,
});
}
callback(null, {
result,
resourceBuffer: processOptions.resourceBuffer,
cacheable: requestCacheable,
fileDependencies,
contextDependencies,
missingDependencies,
});
});
};