310 lines
9.4 KiB
JavaScript
310 lines
9.4 KiB
JavaScript
/*
|
|
MIT License http://www.opensource.org/licenses/mit-license.php
|
|
Author Tobias Koppers @sokra
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
const { SyncWaterfallHook } = require("tapable");
|
|
const util = require("util");
|
|
const RuntimeGlobals = require("./RuntimeGlobals");
|
|
const memorize = require("./util/memorize");
|
|
|
|
/** @typedef {import("webpack-sources").ConcatSource} ConcatSource */
|
|
/** @typedef {import("webpack-sources").Source} Source */
|
|
/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
|
|
/** @typedef {import("./Chunk")} Chunk */
|
|
/** @typedef {import("./Compilation")} Compilation */
|
|
/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
|
|
/** @typedef {import("./Module")} Module} */
|
|
/** @typedef {import("./util/Hash")} Hash} */
|
|
/** @typedef {import("./DependencyTemplates")} DependencyTemplates} */
|
|
/** @typedef {import("./ModuleTemplate").RenderContext} RenderContext} */
|
|
/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate} */
|
|
/** @typedef {import("./ModuleGraph")} ModuleGraph} */
|
|
/** @typedef {import("./ChunkGraph")} ChunkGraph} */
|
|
/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions} */
|
|
/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry} */
|
|
|
|
const getJavascriptModulesPlugin = memorize(() =>
|
|
require("./javascript/JavascriptModulesPlugin")
|
|
);
|
|
|
|
// TODO webpack 6 remove this class
|
|
class MainTemplate {
|
|
/**
|
|
*
|
|
* @param {TODO=} outputOptions output options for the MainTemplate
|
|
* @param {Compilation} compilation the compilation
|
|
*/
|
|
constructor(outputOptions, compilation) {
|
|
/** @type {TODO?} */
|
|
this._outputOptions = outputOptions || {};
|
|
this.hooks = Object.freeze({
|
|
renderManifest: {
|
|
tap: util.deprecate(
|
|
(options, fn) => {
|
|
compilation.hooks.renderManifest.tap(
|
|
options,
|
|
(entries, options) => {
|
|
if (!options.chunk.hasRuntime()) return entries;
|
|
return fn(entries, options);
|
|
}
|
|
);
|
|
},
|
|
"MainTemplate.hooks.renderManifest is deprecated (use Compilation.hooks.renderManifest instead)",
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_RENDER_MANIFEST"
|
|
)
|
|
},
|
|
modules: {
|
|
tap: () => {
|
|
throw new Error(
|
|
"MainTemplate.hooks.modules has been removed (there is no replacement, please create an issue to request that)"
|
|
);
|
|
}
|
|
},
|
|
moduleObj: {
|
|
tap: () => {
|
|
throw new Error(
|
|
"MainTemplate.hooks.moduleObj has been removed (there is no replacement, please create an issue to request that)"
|
|
);
|
|
}
|
|
},
|
|
require: {
|
|
tap: util.deprecate(
|
|
(options, fn) => {
|
|
getJavascriptModulesPlugin()
|
|
.getCompilationHooks(compilation)
|
|
.renderRequire.tap(options, fn);
|
|
},
|
|
"MainTemplate.hooks.require is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderRequire instead)",
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_REQUIRE"
|
|
)
|
|
},
|
|
beforeStartup: {
|
|
tap: () => {
|
|
throw new Error(
|
|
"MainTemplate.hooks.beforeStartup has been removed (use RuntimeGlobals.startup instead)"
|
|
);
|
|
}
|
|
},
|
|
startup: {
|
|
tap: () => {
|
|
throw new Error(
|
|
"MainTemplate.hooks.startup has been removed (use RuntimeGlobals.startup instead)"
|
|
);
|
|
}
|
|
},
|
|
afterStartup: {
|
|
tap: () => {
|
|
throw new Error(
|
|
"MainTemplate.hooks.afterStartup has been removed (use RuntimeGlobals.startup instead)"
|
|
);
|
|
}
|
|
},
|
|
render: {
|
|
tap: util.deprecate(
|
|
(options, fn) => {
|
|
getJavascriptModulesPlugin()
|
|
.getCompilationHooks(compilation)
|
|
.render.tap(options, (source, renderContext) => {
|
|
if (
|
|
renderContext.chunkGraph.getNumberOfEntryModules(
|
|
renderContext.chunk
|
|
) === 0 ||
|
|
!renderContext.chunk.hasRuntime()
|
|
) {
|
|
return source;
|
|
}
|
|
return fn(
|
|
source,
|
|
renderContext.chunk,
|
|
compilation.hash,
|
|
compilation.moduleTemplates.javascript,
|
|
compilation.dependencyTemplates
|
|
);
|
|
});
|
|
},
|
|
"MainTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)",
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_RENDER"
|
|
)
|
|
},
|
|
renderWithEntry: {
|
|
tap: util.deprecate(
|
|
(options, fn) => {
|
|
getJavascriptModulesPlugin()
|
|
.getCompilationHooks(compilation)
|
|
.render.tap(options, (source, renderContext) => {
|
|
if (
|
|
renderContext.chunkGraph.getNumberOfEntryModules(
|
|
renderContext.chunk
|
|
) === 0 ||
|
|
!renderContext.chunk.hasRuntime()
|
|
) {
|
|
return source;
|
|
}
|
|
return fn(source, renderContext.chunk, compilation.hash);
|
|
});
|
|
},
|
|
"MainTemplate.hooks.renderWithEntry is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)",
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_RENDER_WITH_ENTRY"
|
|
)
|
|
},
|
|
assetPath: {
|
|
tap: util.deprecate(
|
|
(options, fn) => {
|
|
compilation.hooks.assetPath.tap(options, fn);
|
|
},
|
|
"MainTemplate.hooks.assetPath is deprecated (use Compilation.hooks.assetPath instead)",
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH"
|
|
),
|
|
call: util.deprecate(
|
|
(filename, options) => {
|
|
return compilation.getAssetPath(filename, options);
|
|
},
|
|
"MainTemplate.hooks.assetPath is deprecated (use Compilation.hooks.assetPath instead)",
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH"
|
|
)
|
|
},
|
|
hash: {
|
|
tap: util.deprecate(
|
|
(options, fn) => {
|
|
compilation.hooks.fullHash.tap(options, fn);
|
|
},
|
|
"MainTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)",
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_HASH"
|
|
)
|
|
},
|
|
hashForChunk: {
|
|
tap: util.deprecate(
|
|
(options, fn) => {
|
|
getJavascriptModulesPlugin()
|
|
.getCompilationHooks(compilation)
|
|
.chunkHash.tap(options, (chunk, hash) => {
|
|
if (!chunk.hasRuntime()) return;
|
|
return fn(hash, chunk);
|
|
});
|
|
},
|
|
"MainTemplate.hooks.hashForChunk is deprecated (use JavascriptModulesPlugin.getCompilationHooks().chunkHash instead)",
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK"
|
|
)
|
|
},
|
|
globalHashPaths: {
|
|
tap: util.deprecate(
|
|
() => {},
|
|
"MainTemplate.hooks.globalHashPaths has been removed (it's no longer needed)",
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK"
|
|
)
|
|
},
|
|
globalHash: {
|
|
tap: util.deprecate(
|
|
() => {},
|
|
"MainTemplate.hooks.globalHash has been removed (it's no longer needed)",
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK"
|
|
)
|
|
},
|
|
hotBootstrap: {
|
|
tap: () => {
|
|
throw new Error(
|
|
"MainTemplate.hooks.hotBootstrap has been removed (use your own RuntimeModule instead)"
|
|
);
|
|
}
|
|
},
|
|
|
|
// for compatibility:
|
|
/** @type {SyncWaterfallHook<[string, Chunk, string, ModuleTemplate, DependencyTemplates]>} */
|
|
bootstrap: new SyncWaterfallHook([
|
|
"source",
|
|
"chunk",
|
|
"hash",
|
|
"moduleTemplate",
|
|
"dependencyTemplates"
|
|
]),
|
|
/** @type {SyncWaterfallHook<[string, Chunk, string]>} */
|
|
localVars: new SyncWaterfallHook(["source", "chunk", "hash"]),
|
|
/** @type {SyncWaterfallHook<[string, Chunk, string]>} */
|
|
requireExtensions: new SyncWaterfallHook(["source", "chunk", "hash"]),
|
|
/** @type {SyncWaterfallHook<[string, Chunk, string, string]>} */
|
|
requireEnsure: new SyncWaterfallHook([
|
|
"source",
|
|
"chunk",
|
|
"hash",
|
|
"chunkIdExpression"
|
|
])
|
|
});
|
|
|
|
this.renderCurrentHashCode = util.deprecate(
|
|
/**
|
|
* @deprecated
|
|
* @param {string} hash the hash
|
|
* @param {number=} length length of the hash
|
|
* @returns {string} generated code
|
|
*/ (hash, length) => {
|
|
if (length) {
|
|
return `${RuntimeGlobals.getFullHash} ? ${
|
|
RuntimeGlobals.getFullHash
|
|
}().slice(0, ${length}) : ${hash.slice(0, length)}`;
|
|
}
|
|
return `${RuntimeGlobals.getFullHash} ? ${RuntimeGlobals.getFullHash}() : ${hash}`;
|
|
},
|
|
"MainTemplate.renderCurrentHashCode is deprecated (use RuntimeGlobals.getFullHash runtime function instead)",
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_RENDER_CURRENT_HASH_CODE"
|
|
);
|
|
|
|
this.getPublicPath = util.deprecate(
|
|
/**
|
|
*
|
|
* @param {object} options get public path options
|
|
* @returns {string} hook call
|
|
*/ options => {
|
|
return compilation.getAssetPath(
|
|
compilation.outputOptions.publicPath,
|
|
options
|
|
);
|
|
},
|
|
"MainTemplate.getPublicPath is deprecated (use Compilation.getAssetPath(compilation.outputOptions.publicPath, options) instead)",
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_GET_PUBLIC_PATH"
|
|
);
|
|
|
|
this.getAssetPath = util.deprecate(
|
|
(path, options) => {
|
|
return compilation.getAssetPath(path, options);
|
|
},
|
|
"MainTemplate.getAssetPath is deprecated (use Compilation.getAssetPath instead)",
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH"
|
|
);
|
|
|
|
this.getAssetPathWithInfo = util.deprecate(
|
|
(path, options) => {
|
|
return compilation.getAssetPathWithInfo(path, options);
|
|
},
|
|
"MainTemplate.getAssetPathWithInfo is deprecated (use Compilation.getAssetPath instead)",
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH_WITH_INFO"
|
|
);
|
|
}
|
|
}
|
|
|
|
Object.defineProperty(MainTemplate.prototype, "requireFn", {
|
|
get: util.deprecate(
|
|
() => "__webpack_require__",
|
|
'MainTemplate.requireFn is deprecated (use "__webpack_require__")',
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_REQUIRE_FN"
|
|
)
|
|
});
|
|
|
|
Object.defineProperty(MainTemplate.prototype, "outputOptions", {
|
|
get: util.deprecate(
|
|
/**
|
|
* @this {MainTemplate}
|
|
* @returns {TODO} output options
|
|
*/
|
|
function () {
|
|
return this._outputOptions;
|
|
},
|
|
"MainTemplate.outputOptions is deprecated (use Compilation.outputOptions instead)",
|
|
"DEP_WEBPACK_MAIN_TEMPLATE_OUTPUT_OPTIONS"
|
|
)
|
|
});
|
|
|
|
module.exports = MainTemplate;
|