| /* |
| MIT License http://www.opensource.org/licenses/mit-license.php |
| Author Tobias Koppers @sokra |
| */ |
| /** @typedef {import("./Module")} Module */ |
| /** @typedef {import("./Chunk")} Chunk */ |
| /** @typedef {import("./ModuleTemplate")} ModuleTemplate */ |
| /** @typedef {import("webpack-sources").ConcatSource} ConcatSource */ |
| |
| const { ConcatSource } = require("webpack-sources"); |
| const HotUpdateChunk = require("./HotUpdateChunk"); |
| |
| const START_LOWERCASE_ALPHABET_CODE = "a".charCodeAt(0); |
| const START_UPPERCASE_ALPHABET_CODE = "A".charCodeAt(0); |
| const DELTA_A_TO_Z = "z".charCodeAt(0) - START_LOWERCASE_ALPHABET_CODE + 1; |
| const FUNCTION_CONTENT_REGEX = /^function\s?\(\)\s?\{\r?\n?|\r?\n?\}$/g; |
| const INDENT_MULTILINE_REGEX = /^\t/gm; |
| const LINE_SEPARATOR_REGEX = /\r?\n/g; |
| const IDENTIFIER_NAME_REPLACE_REGEX = /^([^a-zA-Z$_])/; |
| const IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX = /[^a-zA-Z0-9$]+/g; |
| const COMMENT_END_REGEX = /\*\//g; |
| const PATH_NAME_NORMALIZE_REPLACE_REGEX = /[^a-zA-Z0-9_!§$()=\-^°]+/g; |
| const MATCH_PADDED_HYPHENS_REPLACE_REGEX = /^-|-$/g; |
| |
| /** @typedef {import("webpack-sources").Source} Source */ |
| |
| /** |
| * @typedef {Object} HasId |
| * @property {number | string} id |
| */ |
| |
| /** |
| * @typedef {function(Module, number): boolean} ModuleFilterPredicate |
| */ |
| |
| /** |
| * @param {HasId} a first id object to be sorted |
| * @param {HasId} b second id object to be sorted against |
| * @returns {-1|0|1} the sort value |
| */ |
| const stringifyIdSortPredicate = (a, b) => { |
| const aId = a.id + ""; |
| const bId = b.id + ""; |
| if (aId < bId) return -1; |
| if (aId > bId) return 1; |
| return 0; |
| }; |
| |
| class Template { |
| /** |
| * |
| * @param {Function} fn - a runtime function (.runtime.js) "template" |
| * @returns {string} the updated and normalized function string |
| */ |
| static getFunctionContent(fn) { |
| return fn |
| .toString() |
| .replace(FUNCTION_CONTENT_REGEX, "") |
| .replace(INDENT_MULTILINE_REGEX, "") |
| .replace(LINE_SEPARATOR_REGEX, "\n"); |
| } |
| |
| /** |
| * @param {string} str the string converted to identifier |
| * @returns {string} created identifier |
| */ |
| static toIdentifier(str) { |
| if (typeof str !== "string") return ""; |
| return str |
| .replace(IDENTIFIER_NAME_REPLACE_REGEX, "_$1") |
| .replace(IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX, "_"); |
| } |
| /** |
| * |
| * @param {string} str string to be converted to commented in bundle code |
| * @returns {string} returns a commented version of string |
| */ |
| static toComment(str) { |
| if (!str) return ""; |
| return `/*! ${str.replace(COMMENT_END_REGEX, "* /")} */`; |
| } |
| |
| /** |
| * |
| * @param {string} str string to be converted to "normal comment" |
| * @returns {string} returns a commented version of string |
| */ |
| static toNormalComment(str) { |
| if (!str) return ""; |
| return `/* ${str.replace(COMMENT_END_REGEX, "* /")} */`; |
| } |
| |
| /** |
| * @param {string} str string path to be normalized |
| * @returns {string} normalized bundle-safe path |
| */ |
| static toPath(str) { |
| if (typeof str !== "string") return ""; |
| return str |
| .replace(PATH_NAME_NORMALIZE_REPLACE_REGEX, "-") |
| .replace(MATCH_PADDED_HYPHENS_REPLACE_REGEX, ""); |
| } |
| |
| // map number to a single character a-z, A-Z or <_ + number> if number is too big |
| /** |
| * |
| * @param {number} n number to convert to ident |
| * @returns {string} returns single character ident |
| */ |
| static numberToIdentifer(n) { |
| // lower case |
| if (n < DELTA_A_TO_Z) { |
| return String.fromCharCode(START_LOWERCASE_ALPHABET_CODE + n); |
| } |
| |
| // upper case |
| if (n < DELTA_A_TO_Z * 2) { |
| return String.fromCharCode( |
| START_UPPERCASE_ALPHABET_CODE + n - DELTA_A_TO_Z |
| ); |
| } |
| |
| // use multiple letters |
| return ( |
| Template.numberToIdentifer(n % (2 * DELTA_A_TO_Z)) + |
| Template.numberToIdentifer(Math.floor(n / (2 * DELTA_A_TO_Z))) |
| ); |
| } |
| |
| /** |
| * |
| * @param {string | string[]} s string to convert to identity |
| * @returns {string} converted identity |
| */ |
| static indent(s) { |
| if (Array.isArray(s)) { |
| return s.map(Template.indent).join("\n"); |
| } else { |
| const str = s.trimRight(); |
| if (!str) return ""; |
| const ind = str[0] === "\n" ? "" : "\t"; |
| return ind + str.replace(/\n([^\n])/g, "\n\t$1"); |
| } |
| } |
| |
| /** |
| * |
| * @param {string|string[]} s string to create prefix for |
| * @param {string} prefix prefix to compose |
| * @returns {string} returns new prefix string |
| */ |
| static prefix(s, prefix) { |
| const str = Template.asString(s).trim(); |
| if (!str) return ""; |
| const ind = str[0] === "\n" ? "" : prefix; |
| return ind + str.replace(/\n([^\n])/g, "\n" + prefix + "$1"); |
| } |
| |
| /** |
| * |
| * @param {string|string[]} str string or string collection |
| * @returns {string} returns a single string from array |
| */ |
| static asString(str) { |
| if (Array.isArray(str)) { |
| return str.join("\n"); |
| } |
| return str; |
| } |
| |
| /** |
| * @typedef {Object} WithId |
| * @property {string|number} id |
| */ |
| |
| /** |
| * @param {WithId[]} modules a collection of modules to get array bounds for |
| * @returns {[number, number] | false} returns the upper and lower array bounds |
| * or false if not every module has a number based id |
| */ |
| static getModulesArrayBounds(modules) { |
| let maxId = -Infinity; |
| let minId = Infinity; |
| for (const module of modules) { |
| if (typeof module.id !== "number") return false; |
| if (maxId < module.id) maxId = /** @type {number} */ (module.id); |
| if (minId > module.id) minId = /** @type {number} */ (module.id); |
| } |
| if (minId < 16 + ("" + minId).length) { |
| // add minId x ',' instead of 'Array(minId).concat(…)' |
| minId = 0; |
| } |
| const objectOverhead = modules |
| .map(module => (module.id + "").length + 2) |
| .reduce((a, b) => a + b, -1); |
| const arrayOverhead = |
| minId === 0 ? maxId : 16 + ("" + minId).length + maxId; |
| return arrayOverhead < objectOverhead ? [minId, maxId] : false; |
| } |
| |
| /** |
| * @param {Chunk} chunk chunk whose modules will be rendered |
| * @param {ModuleFilterPredicate} filterFn function used to filter modules from chunk to render |
| * @param {ModuleTemplate} moduleTemplate ModuleTemplate instance used to render modules |
| * @param {TODO | TODO[]} dependencyTemplates templates needed for each module to render dependencies |
| * @param {string=} prefix applying prefix strings |
| * @returns {ConcatSource} rendered chunk modules in a Source object |
| */ |
| static renderChunkModules( |
| chunk, |
| filterFn, |
| moduleTemplate, |
| dependencyTemplates, |
| prefix = "" |
| ) { |
| const source = new ConcatSource(); |
| const modules = chunk.getModules().filter(filterFn); |
| let removedModules; |
| if (chunk instanceof HotUpdateChunk) { |
| removedModules = chunk.removedModules; |
| } |
| if ( |
| modules.length === 0 && |
| (!removedModules || removedModules.length === 0) |
| ) { |
| source.add("[]"); |
| return source; |
| } |
| /** @type {{id: string|number, source: Source|string}[]} */ |
| const allModules = modules.map(module => { |
| return { |
| id: module.id, |
| source: moduleTemplate.render(module, dependencyTemplates, { |
| chunk |
| }) |
| }; |
| }); |
| if (removedModules && removedModules.length > 0) { |
| for (const id of removedModules) { |
| allModules.push({ |
| id, |
| source: "false" |
| }); |
| } |
| } |
| const bounds = Template.getModulesArrayBounds(allModules); |
| if (bounds) { |
| // Render a spare array |
| const minId = bounds[0]; |
| const maxId = bounds[1]; |
| if (minId !== 0) { |
| source.add(`Array(${minId}).concat(`); |
| } |
| source.add("[\n"); |
| /** @type {Map<string|number, {id: string|number, source: Source|string}>} */ |
| const modules = new Map(); |
| for (const module of allModules) { |
| modules.set(module.id, module); |
| } |
| for (let idx = minId; idx <= maxId; idx++) { |
| const module = modules.get(idx); |
| if (idx !== minId) { |
| source.add(",\n"); |
| } |
| source.add(`/* ${idx} */`); |
| if (module) { |
| source.add("\n"); |
| source.add(module.source); |
| } |
| } |
| source.add("\n" + prefix + "]"); |
| if (minId !== 0) { |
| source.add(")"); |
| } |
| } else { |
| // Render an object |
| source.add("{\n"); |
| allModules.sort(stringifyIdSortPredicate).forEach((module, idx) => { |
| if (idx !== 0) { |
| source.add(",\n"); |
| } |
| source.add(`\n/***/ ${JSON.stringify(module.id)}:\n`); |
| source.add(module.source); |
| }); |
| source.add(`\n\n${prefix}}`); |
| } |
| return source; |
| } |
| } |
| |
| module.exports = Template; |