const nodeObjectHash = require('node-object-hash');
|
const parseJson = require('parse-json');
|
|
const serial = require('./util/serial');
|
const pluginCompat = require('./util/plugin-compat');
|
const relateContext = require('./util/relate-context');
|
const { parityCacheFromCache, pushParityWriteOps } = require('./util/parity');
|
|
const serialJsonKey = {
|
freeze(arg, value, extra) {
|
return JSON.parse(arg);
|
},
|
thaw(arg, frozen, extra) {
|
return JSON.stringify(arg);
|
},
|
};
|
|
const serialJson = {
|
freeze(arg, value, extra) {
|
return JSON.stringify(arg);
|
},
|
thaw(arg, frozen, extra) {
|
return JSON.parse(arg);
|
},
|
};
|
|
const serialObjectAssign = serial.objectAssign;
|
|
const serialResolveOptionsKey = serialObjectAssign({
|
context: serial.path,
|
userRequest: serial.request,
|
options: serialObjectAssign({
|
request: serial.request,
|
}),
|
});
|
|
const serialResolveKey = serialObjectAssign({
|
context: serial.path,
|
request: serial.request,
|
});
|
|
const serialNormalModuleResolveKey = serial.pipe(
|
serialJsonKey,
|
{
|
freeze(arg, key, extra) {
|
if (Array.isArray(arg)) {
|
return [
|
arg[0],
|
serial.path.freeze(arg[1], arg[1], extra),
|
serial.request.freeze(arg[2], arg[2], extra),
|
];
|
} else if (!arg.request) {
|
return serialResolveOptionsKey.freeze(arg, arg, extra);
|
} else {
|
return serialResolveKey.freeze(arg, arg, extra);
|
}
|
},
|
thaw(arg, frozen, extra) {
|
if (Array.isArray(arg)) {
|
return [
|
arg[0],
|
serial.path.thaw(arg[1], arg[1], extra),
|
serial.request.thaw(arg[2], arg[2], extra),
|
];
|
} else if (!arg.request) {
|
return serialResolveOptionsKey.thaw(arg, arg, extra);
|
} else {
|
return serialResolveKey.thaw(arg, arg, extra);
|
}
|
},
|
},
|
serialJson,
|
);
|
|
const serialNormalModuleId = {
|
freeze(arg, module, extra) {
|
return (
|
id.substring(0, 24) + serial.request.freeze(id.substring(24), id, extra)
|
);
|
},
|
thaw(arg, frozen, extra) {
|
return (
|
id.substring(0, 24) + serial.request.thaw(id.substring(24), id, extra)
|
);
|
},
|
};
|
|
const serialResolveContext = serialObjectAssign({
|
identifier: serialNormalModuleId,
|
resource: serialNormalModuleId,
|
});
|
|
const serialResolveNormal = serialObjectAssign({
|
context: serial.path,
|
request: serial.request,
|
userRequest: serial.request,
|
rawRequest: serial.request,
|
resource: serial.request,
|
loaders: serial.loaders,
|
resourceResolveData: serial.objectAssign({
|
context: serial.created({
|
issuer: serial.request,
|
resolveOptions: serial.identity,
|
}),
|
path: serial.path,
|
request: serial.request,
|
descriptionFilePath: serial.path,
|
descriptionFileRoot: serial.path,
|
}),
|
});
|
|
const serialResolve = {
|
freeze(arg, module, extra) {
|
if (arg.type === 'context') {
|
return serialResolveContext.freeze(arg, arg, extra);
|
}
|
return serialResolveNormal.freeze(arg, arg, extra);
|
},
|
thaw(arg, frozen, extra) {
|
if (arg.type === 'context') {
|
return serialResolveContext.thaw(arg, arg, extra);
|
}
|
return serialResolveNormal.thaw(arg, arg, extra);
|
},
|
};
|
|
class ModuleResolverCache {
|
apply(compiler) {
|
let moduleResolveCache = {};
|
let parityCache = {};
|
|
let moduleResolveCacheChange = [];
|
|
let moduleResolveCacheSerializer;
|
|
const compilerHooks = pluginCompat.hooks(compiler);
|
|
compilerHooks._hardSourceCreateSerializer.tap(
|
'HardSource - ModuleResolverCache',
|
(cacheSerializerFactory, cacheDirPath) => {
|
moduleResolveCacheSerializer = cacheSerializerFactory.create({
|
name: 'module-resolve',
|
type: 'data',
|
autoParse: true,
|
cacheDirPath,
|
});
|
},
|
);
|
|
compilerHooks._hardSourceResetCache.tap(
|
'HardSource - ModuleResolverCache',
|
() => {
|
moduleResolveCache = {};
|
parityCache = {};
|
},
|
);
|
|
compilerHooks._hardSourceReadCache.tapPromise(
|
'HardSource - ModuleResolverCache',
|
({
|
contextKeys,
|
contextValues,
|
contextNormalPath,
|
contextNormalRequest,
|
contextNormalModuleId,
|
copyWithDeser,
|
}) => {
|
function contextNormalModuleResolveKey(compiler, key) {
|
if (key.startsWith('__hardSource_parityToken')) {
|
return key;
|
}
|
const parsed = parseJson(key);
|
if (Array.isArray(parsed)) {
|
return JSON.stringify([
|
parsed[0],
|
contextNormalPath(compiler, parsed[1]),
|
parsed[2],
|
]);
|
} else {
|
return JSON.stringify(
|
Object.assign({}, parsed, {
|
context: contextNormalPath(compiler, parsed.context),
|
}),
|
);
|
}
|
}
|
|
function contextNormalModuleResolve(compiler, resolved, key) {
|
if (key.startsWith('__hardSource_parityToken')) {
|
parityCache[key] = resolved;
|
return;
|
}
|
if (typeof resolved === 'string') {
|
resolved = parseJson(resolved);
|
}
|
if (resolved.type === 'context') {
|
return Object.assign({}, resolved, {
|
identifier: contextNormalModuleId(compiler, resolved.identifier),
|
resource: contextNormalRequest(compiler, resolved.resource),
|
});
|
}
|
return serialResolveNormal.thaw(resolved, resolved, {
|
compiler,
|
});
|
}
|
|
return moduleResolveCacheSerializer
|
.read()
|
.then(contextKeys(compiler, contextNormalModuleResolveKey))
|
.then(contextValues(compiler, contextNormalModuleResolve))
|
.then(copyWithDeser.bind(null, moduleResolveCache));
|
},
|
);
|
|
compilerHooks._hardSourceParityCache.tap(
|
'HardSource - ModuleResolverCache',
|
parityRoot => {
|
parityCacheFromCache('ModuleResolver', parityRoot, parityCache);
|
},
|
);
|
|
compilerHooks._hardSourceVerifyCache.tapPromise(
|
'HardSource - ModuleResolverCache',
|
() =>
|
compiler.__hardSource_missingVerify.then(() => {
|
const missingCache = compiler.__hardSource_missingCache;
|
|
// Invalidate resolve cache items.
|
Object.keys(moduleResolveCache).forEach(key => {
|
const resolveKey = parseJson(key);
|
const resolveItem = moduleResolveCache[key];
|
let normalId = 'normal';
|
if (resolveItem.resolveOptions) {
|
normalId = `normal-${new nodeObjectHash({ sort: false }).hash(
|
resolveItem.resolveOptions,
|
)}`;
|
}
|
if (resolveItem.type === 'context') {
|
const contextMissing =
|
missingCache.context[
|
JSON.stringify([
|
resolveKey.context,
|
resolveItem.resource.split('?')[0],
|
])
|
];
|
if (!contextMissing || contextMissing.invalid) {
|
resolveItem.invalid = true;
|
resolveItem.invalidReason = 'resolved context invalid';
|
}
|
} else {
|
const normalMissing =
|
missingCache[normalId] &&
|
missingCache[normalId][
|
JSON.stringify([
|
resolveKey[1],
|
resolveItem.resource.split('?')[0],
|
])
|
];
|
if (!normalMissing || normalMissing.invalid) {
|
resolveItem.invalid = true;
|
resolveItem.invalidReason = `resolved normal invalid${
|
normalMissing
|
? ` ${normalMissing.invalidReason}`
|
: ': resolve entry not in cache'
|
}`;
|
}
|
resolveItem.loaders.forEach(loader => {
|
if (typeof loader === 'object') {
|
if (loader.loader != null) {
|
loader = loader.loader;
|
} else {
|
// Convert { "0": "b", "1": "a", "2": "r" } into "bar"
|
loader = Object.assign([], loader).join('');
|
}
|
}
|
// Loaders specified in a dependency are searched for from the
|
// context of the module containing that dependency.
|
let loaderMissing =
|
missingCache.loader[
|
JSON.stringify([resolveKey[1], loader.split('?')[0]])
|
];
|
if (!loaderMissing) {
|
// webpack searches for rule based loaders from the project
|
// context.
|
loaderMissing =
|
missingCache.loader[
|
JSON.stringify([
|
// compiler may be a Watching instance, which refers to the
|
// compiler
|
(compiler.options || compiler.compiler.options).context,
|
loader.split('?')[0],
|
])
|
];
|
}
|
if (!loaderMissing || loaderMissing.invalid) {
|
resolveItem.invalid = true;
|
resolveItem.invalidReason = 'resolved loader invalid';
|
}
|
});
|
}
|
});
|
}),
|
);
|
|
compilerHooks.compilation.tap(
|
'HardSource - ModuleResolverCache',
|
compilation => {
|
compilation.__hardSourceModuleResolveCache = moduleResolveCache;
|
compilation.__hardSourceModuleResolveCacheChange = moduleResolveCacheChange;
|
},
|
);
|
|
compilerHooks._hardSourceWriteCache.tapPromise(
|
'HardSource - ModuleResolverCache',
|
(
|
compilation,
|
{ relateNormalPath, relateNormalModuleId, relateNormalRequest },
|
) => {
|
if (compilation.compiler.parentCompilation) {
|
const moduleResolveOps = [];
|
pushParityWriteOps(compilation, moduleResolveOps);
|
|
return moduleResolveCacheSerializer.write(moduleResolveOps);
|
}
|
|
const moduleResolveOps = [];
|
|
function relateNormalModuleResolveKey(compiler, key) {
|
const parsed = parseJson(key);
|
if (Array.isArray(parsed)) {
|
return JSON.stringify([
|
parsed[0],
|
relateNormalPath(compiler, parsed[1]),
|
relateContext.relateAbsoluteRequest(parsed[1], parsed[2]),
|
]);
|
} else {
|
if (!parsed.request) {
|
return JSON.stringify(
|
Object.assign({}, parsed, {
|
context: relateNormalPath(compiler, parsed.context),
|
userRequest: relateContext.relateAbsoluteRequest(
|
parsed.context,
|
parsed.userRequest,
|
),
|
options: Object.assign({}, parsed.options, {
|
request: relateContext.relateAbsoluteRequest(
|
parsed.context,
|
parsed.options.request,
|
),
|
}),
|
}),
|
);
|
} else {
|
return JSON.stringify(
|
Object.assign({}, parsed, {
|
context: relateNormalPath(compiler, parsed.context),
|
request: relateContext.relateAbsoluteRequest(
|
parsed.context,
|
parsed.request,
|
),
|
}),
|
);
|
}
|
}
|
}
|
|
function relateNormalModuleResolve(compiler, resolved) {
|
if (resolved.type === 'context') {
|
return Object.assign({}, resolved, {
|
identifier: relateNormalModuleId(compiler, resolved.identifier),
|
resource: relateNormalRequest(compiler, resolved.resource),
|
});
|
}
|
return serialResolveNormal.freeze(resolved, resolved, {
|
compiler,
|
});
|
}
|
|
moduleResolveCacheChange
|
.reduce((carry, value) => {
|
if (!carry.includes(value)) {
|
carry.push(value);
|
}
|
return carry;
|
}, [])
|
.forEach(key => {
|
// console.log(key, moduleResolveCache[key]);
|
// moduleResolveCache[key] && console.log(relateNormalModuleResolveKey(compiler, key));
|
// moduleResolveCache[key] && console.log(relateNormalModuleResolve(compiler, moduleResolveCache[key]));
|
moduleResolveOps.push({
|
key: relateNormalModuleResolveKey(compiler, key),
|
value: moduleResolveCache[key]
|
? relateNormalModuleResolve(compiler, moduleResolveCache[key])
|
: null,
|
});
|
});
|
|
moduleResolveCacheChange = [];
|
|
pushParityWriteOps(compilation, moduleResolveOps);
|
|
return moduleResolveCacheSerializer.write(moduleResolveOps);
|
},
|
);
|
}
|
}
|
|
module.exports = ModuleResolverCache;
|
