const relateContext = require('./util/relate-context');
|
const pluginCompat = require('./util/plugin-compat');
|
|
const SourceSchemas3 = [
|
['CachedSource', 'source'],
|
['ConcatSource'],
|
['LineToLineMappedSource', 'value', 'name', 'originalSource'],
|
['OriginalSource', 'value', 'name'],
|
['RawSource', 'value'],
|
['ReplaceSource', 'source', 'name'],
|
[
|
'SourceMapSource',
|
'value',
|
'name',
|
'sourceMap',
|
'originalSource',
|
'innerSourceMap',
|
],
|
];
|
|
try {
|
SourceSchemas3[0].Source = require('webpack-sources/lib/CachedSource');
|
} catch (_) {}
|
try {
|
SourceSchemas3[1].Source = require('webpack-sources/lib/ConcatSource');
|
} catch (_) {}
|
try {
|
SourceSchemas3[2].Source = require('webpack-sources/lib/LineToLineMappedSource');
|
} catch (_) {}
|
try {
|
SourceSchemas3[3].Source = require('webpack-sources/lib/OriginalSource');
|
} catch (_) {}
|
try {
|
SourceSchemas3[4].Source = require('webpack-sources/lib/RawSource');
|
} catch (_) {}
|
try {
|
SourceSchemas3[5].Source = require('webpack-sources/lib/ReplaceSource');
|
} catch (_) {}
|
try {
|
SourceSchemas3[6].Source = require('webpack-sources/lib/SourceMapSource');
|
} catch (_) {}
|
|
const freezeArgument = {
|
value(arg, { _value }, extra, methods) {
|
return _value;
|
},
|
name(arg, { _name }, { compilation }, methods) {
|
try {
|
return relateContext.relateNormalPath(compilation.compiler, _name);
|
} catch (e) {
|
console.error(e.stack);
|
process.exit();
|
}
|
},
|
sourceMap(arg, { _sourceMap }, extra, methods) {
|
return _sourceMap;
|
},
|
originalSource(arg, { _originalSource }, extra, methods) {
|
return _originalSource;
|
},
|
innerSourceMap(arg, { _innerSourceMap }, extra, methods) {
|
return _innerSourceMap;
|
},
|
source(arg, { constructor, _source }, extra, methods) {
|
if (constructor.name === 'ReplaceSource') {
|
return;
|
}
|
return methods.freeze('Source', null, _source, extra);
|
},
|
};
|
|
const thawArgument = {
|
name(arg, source, { compilation }, methods) {
|
try {
|
return relateContext.contextNormalPath(compilation.compiler, arg);
|
} catch (e) {
|
console.error(e.stack);
|
process.exit();
|
}
|
},
|
source(arg, { type }, extra, methods) {
|
if (type === 'ReplaceSource') {
|
return extra.source;
|
}
|
return methods.thaw('Source', null, arg, extra);
|
},
|
value(arg, frozen, extra, methods) {
|
if (arg && arg.type === 'Buffer') {
|
return new Buffer(arg.data);
|
}
|
return arg;
|
},
|
};
|
|
function freezeSource(source, extra, methods) {
|
const schemas = extra.schemas;
|
for (let i = 0; i < schemas.length; i++) {
|
if (source.constructor.name === schemas[i].Source.name) {
|
const frozen = {
|
type: schemas[i][0],
|
};
|
for (let j = 1; j < schemas[i].length; j++) {
|
let arg = source[schemas[i][j]];
|
if (freezeArgument[schemas[i][j]]) {
|
arg = freezeArgument[schemas[i][j]](arg, source, extra, methods);
|
}
|
frozen[schemas[i][j]] = arg;
|
}
|
return frozen;
|
}
|
}
|
|
throw new Error(`Unfrozen ${source.constructor.name}.`);
|
}
|
|
function thawSource(frozen, extra, methods) {
|
const schemas = extra.schemas;
|
for (let i = 0; i < schemas.length; i++) {
|
if (frozen.type === schemas[i][0]) {
|
const Source = schemas[i].Source;
|
const args = [];
|
for (let j = 1; j < schemas[i].length; j++) {
|
let arg = frozen[schemas[i][j]];
|
if (thawArgument[schemas[i][j]]) {
|
arg = thawArgument[schemas[i][j]](arg, frozen, extra, methods);
|
}
|
args.push(arg);
|
}
|
try {
|
return new Source(...args);
|
} catch (_) {
|
return new (Function.prototype.bind.apply(
|
Source,
|
[null].concat(args),
|
))();
|
}
|
}
|
}
|
}
|
|
class TransformSourcePlugin {
|
apply(compiler) {
|
let methods;
|
|
pluginCompat.tap(
|
compiler,
|
'_hardSourceMethods',
|
'TransformSourcePlugin',
|
_methods => {
|
methods = _methods;
|
},
|
);
|
|
pluginCompat.tap(
|
compiler,
|
'_hardSourceFreezeSource',
|
'TransformSourcePlugin freeze',
|
(frozen, source, extra) => {
|
if (typeof source === 'string') {
|
return {
|
type: 'String',
|
value: source,
|
};
|
} else if (Buffer.isBuffer && Buffer.isBuffer(source)) {
|
// Serialization layer might transform it into JSON or handle it as binary
|
// data
|
return source;
|
}
|
|
extra.schemas = SourceSchemas3;
|
frozen = freezeSource(source, extra, methods);
|
if (frozen.type === 'ReplaceSource') {
|
frozen.replacements = source.replacements;
|
} else if (frozen.type === 'CachedSource') {
|
frozen.cachedSource = source._cachedSource;
|
frozen.cachedSize = source._cachedSize;
|
frozen.cachedMaps = source._cachedMaps;
|
} else if (frozen.type === 'ConcatSource') {
|
frozen.children = methods.mapFreeze(
|
'Source',
|
null,
|
source.children,
|
extra,
|
);
|
}
|
return frozen;
|
},
|
);
|
|
pluginCompat.tap(
|
compiler,
|
'_hardSourceThawSource',
|
'TransformSourcePlugin thaw',
|
(source, frozen, extra) => {
|
if (frozen.type === 'String') {
|
return frozen.value;
|
} else if (frozen.type === 'Buffer') {
|
return new Buffer(frozen.data);
|
} else if (Buffer.isBuffer && Buffer.isBuffer(frozen)) {
|
return frozen;
|
}
|
|
extra.schemas = SourceSchemas3;
|
source = thawSource(frozen, extra, methods);
|
if (frozen.type === 'ReplaceSource') {
|
source.replacements = frozen.replacements;
|
} else if (frozen.type === 'CachedSource') {
|
source._cachedSource = frozen.cachedSource;
|
source._cachedSize = frozen.cachedSize;
|
source._cachedMaps = frozen.cachedMaps;
|
} else if (frozen.type === 'ConcatSource') {
|
source.children = methods.mapThaw(
|
'Source',
|
null,
|
frozen.children,
|
extra,
|
);
|
}
|
return source;
|
},
|
);
|
}
|
}
|
|
module.exports = TransformSourcePlugin;
|
