progress on migrating to heex templates and font-icons

assets_old/node_modules/webpack/lib/asset/AssetGenerator.js

@@ -0,0 +1,304 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sergey Melyukov @smelukov
+*/
+
+"use strict";
+
+const mimeTypes = require("mime-types");
+const path = require("path");
+const { RawSource } = require("webpack-sources");
+const Generator = require("../Generator");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const createHash = require("../util/createHash");
+const { makePathsRelative } = require("../util/identifier");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").AssetGeneratorOptions} AssetGeneratorOptions */
+/** @typedef {import("../../declarations/WebpackOptions").RawPublicPath} RawPublicPath */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../util/Hash")} Hash */
+
+const mergeMaybeArrays = (a, b) => {
+	const set = new Set();
+	if (Array.isArray(a)) for (const item of a) set.add(item);
+	else set.add(a);
+	if (Array.isArray(b)) for (const item of b) set.add(item);
+	else set.add(b);
+	return Array.from(set);
+};
+
+const mergeAssetInfo = (a, b) => {
+	const result = { ...a, ...b };
+	for (const key of Object.keys(a)) {
+		if (key in b) {
+			if (a[key] === b[key]) continue;
+			switch (key) {
+				case "fullhash":
+				case "chunkhash":
+				case "modulehash":
+				case "contenthash":
+					result[key] = mergeMaybeArrays(a[key], b[key]);
+					break;
+				case "immutable":
+				case "development":
+				case "hotModuleReplacement":
+				case "javascriptModule	":
+					result[key] = a[key] || b[key];
+					break;
+				case "related":
+					result[key] = mergeRelatedInfo(a[key], b[key]);
+					break;
+				default:
+					throw new Error(`Can't handle conflicting asset info for ${key}`);
+			}
+		}
+	}
+	return result;
+};
+
+const mergeRelatedInfo = (a, b) => {
+	const result = { ...a, ...b };
+	for (const key of Object.keys(a)) {
+		if (key in b) {
+			if (a[key] === b[key]) continue;
+			result[key] = mergeMaybeArrays(a[key], b[key]);
+		}
+	}
+	return result;
+};
+
+const JS_TYPES = new Set(["javascript"]);
+const JS_AND_ASSET_TYPES = new Set(["javascript", "asset"]);
+
+class AssetGenerator extends Generator {
+	/**
+	 * @param {AssetGeneratorOptions["dataUrl"]=} dataUrlOptions the options for the data url
+	 * @param {string=} filename override for output.assetModuleFilename
+	 * @param {RawPublicPath=} publicPath override for output.assetModulePublicPath
+	 * @param {boolean=} emit generate output asset
+	 */
+	constructor(dataUrlOptions, filename, publicPath, emit) {
+		super();
+		this.dataUrlOptions = dataUrlOptions;
+		this.filename = filename;
+		this.publicPath = publicPath;
+		this.emit = emit;
+	}
+
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
+	 */
+	generate(
+		module,
+		{ runtime, chunkGraph, runtimeTemplate, runtimeRequirements, type, getData }
+	) {
+		switch (type) {
+			case "asset":
+				return module.originalSource();
+			default: {
+				runtimeRequirements.add(RuntimeGlobals.module);
+
+				const originalSource = module.originalSource();
+				if (module.buildInfo.dataUrl) {
+					let encodedSource;
+					if (typeof this.dataUrlOptions === "function") {
+						encodedSource = this.dataUrlOptions.call(
+							null,
+							originalSource.source(),
+							{
+								filename: module.matchResource || module.resource,
+								module
+							}
+						);
+					} else {
+						const encoding = this.dataUrlOptions.encoding;
+						const ext = path.extname(module.nameForCondition());
+						const mimeType =
+							this.dataUrlOptions.mimetype || mimeTypes.lookup(ext);
+
+						if (!mimeType) {
+							throw new Error(
+								"DataUrl can't be generated automatically, " +
+									`because there is no mimetype for "${ext}" in mimetype database. ` +
+									'Either pass a mimetype via "generator.mimetype" or ' +
+									'use type: "asset/resource" to create a resource file instead of a DataUrl'
+							);
+						}
+
+						let encodedContent;
+						switch (encoding) {
+							case "base64": {
+								encodedContent = originalSource.buffer().toString("base64");
+								break;
+							}
+							case false: {
+								const content = originalSource.source();
+								if (typeof content === "string") {
+									encodedContent = encodeURI(content);
+								} else {
+									encodedContent = encodeURI(content.toString("utf-8"));
+								}
+								break;
+							}
+							default:
+								throw new Error(`Unsupported encoding '${encoding}'`);
+						}
+
+						encodedSource = `data:${mimeType}${
+							encoding ? `;${encoding}` : ""
+						},${encodedContent}`;
+					}
+					return new RawSource(
+						`${RuntimeGlobals.module}.exports = ${JSON.stringify(
+							encodedSource
+						)};`
+					);
+				} else {
+					const assetModuleFilename =
+						this.filename || runtimeTemplate.outputOptions.assetModuleFilename;
+					const hash = createHash(runtimeTemplate.outputOptions.hashFunction);
+					if (runtimeTemplate.outputOptions.hashSalt) {
+						hash.update(runtimeTemplate.outputOptions.hashSalt);
+					}
+					hash.update(originalSource.buffer());
+					const fullHash = /** @type {string} */ (hash.digest(
+						runtimeTemplate.outputOptions.hashDigest
+					));
+					const contentHash = fullHash.slice(
+						0,
+						runtimeTemplate.outputOptions.hashDigestLength
+					);
+					module.buildInfo.fullContentHash = fullHash;
+					const sourceFilename = makePathsRelative(
+						runtimeTemplate.compilation.compiler.context,
+						module.matchResource || module.resource,
+						runtimeTemplate.compilation.compiler.root
+					).replace(/^\.\//, "");
+					let {
+						path: filename,
+						info: assetInfo
+					} = runtimeTemplate.compilation.getAssetPathWithInfo(
+						assetModuleFilename,
+						{
+							module,
+							runtime,
+							filename: sourceFilename,
+							chunkGraph,
+							contentHash
+						}
+					);
+					let publicPath;
+					if (this.publicPath) {
+						const {
+							path,
+							info
+						} = runtimeTemplate.compilation.getAssetPathWithInfo(
+							this.publicPath,
+							{
+								module,
+								runtime,
+								filename: sourceFilename,
+								chunkGraph,
+								contentHash
+							}
+						);
+						publicPath = JSON.stringify(path);
+						assetInfo = mergeAssetInfo(assetInfo, info);
+					} else {
+						publicPath = RuntimeGlobals.publicPath;
+						runtimeRequirements.add(RuntimeGlobals.publicPath); // add __webpack_require__.p
+					}
+					assetInfo = {
+						sourceFilename,
+						...assetInfo
+					};
+					module.buildInfo.filename = filename;
+					module.buildInfo.assetInfo = assetInfo;
+					if (getData) {
+						// Due to code generation caching module.buildInfo.XXX can't used to store such information
+						// It need to be stored in the code generation results instead, where it's cached too
+						// TODO webpack 6 For back-compat reasons we also store in on module.buildInfo
+						const data = getData();
+						data.set("fullContentHash", fullHash);
+						data.set("filename", filename);
+						data.set("assetInfo", assetInfo);
+					}
+
+					return new RawSource(
+						`${
+							RuntimeGlobals.module
+						}.exports = ${publicPath} + ${JSON.stringify(filename)};`
+					);
+				}
+			}
+		}
+	}
+
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		if (module.buildInfo.dataUrl || this.emit === false) {
+			return JS_TYPES;
+		} else {
+			return JS_AND_ASSET_TYPES;
+		}
+	}
+
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		switch (type) {
+			case "asset": {
+				const originalSource = module.originalSource();
+
+				if (!originalSource) {
+					return 0;
+				}
+
+				return originalSource.size();
+			}
+			default:
+				if (module.buildInfo.dataUrl) {
+					const originalSource = module.originalSource();
+
+					if (!originalSource) {
+						return 0;
+					}
+
+					// roughly for data url
+					// Example: m.exports="data:image/png;base64,ag82/f+2=="
+					// 4/3 = base64 encoding
+					// 34 = ~ data url header + footer + rounding
+					return originalSource.size() * 1.34 + 36;
+				} else {
+					// it's only estimated so this number is probably fine
+					// Example: m.exports=r.p+"0123456789012345678901.ext"
+					return 42;
+				}
+		}
+	}
+
+	/**
+	 * @param {Hash} hash hash that will be modified
+	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 */
+	updateHash(hash, { module }) {
+		hash.update(module.buildInfo.dataUrl ? "data-url" : "resource");
+	}
+}
+
+module.exports = AssetGenerator;

assets_old/node_modules/webpack/lib/asset/AssetModulesPlugin.js

@@ -0,0 +1,184 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Yuta Hiroto @hiroppy
+*/
+
+"use strict";
+
+const { validate } = require("schema-utils");
+const { cleverMerge } = require("../util/cleverMerge");
+const { compareModulesByIdentifier } = require("../util/comparators");
+const memoize = require("../util/memoize");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+
+const getSchema = name => {
+	const { definitions } = require("../../schemas/WebpackOptions.json");
+	return {
+		definitions,
+		oneOf: [{ $ref: `#/definitions/${name}` }]
+	};
+};
+const getGeneratorSchemaMap = {
+	asset: memoize(() => getSchema("AssetGeneratorOptions")),
+	"asset/resource": memoize(() => getSchema("AssetResourceGeneratorOptions")),
+	"asset/inline": memoize(() => getSchema("AssetInlineGeneratorOptions"))
+};
+
+const getParserSchema = memoize(() => getSchema("AssetParserOptions"));
+const getAssetGenerator = memoize(() => require("./AssetGenerator"));
+const getAssetParser = memoize(() => require("./AssetParser"));
+const getAssetSourceParser = memoize(() => require("./AssetSourceParser"));
+const getAssetSourceGenerator = memoize(() =>
+	require("./AssetSourceGenerator")
+);
+
+const type = "asset";
+const plugin = "AssetModulesPlugin";
+
+class AssetModulesPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			plugin,
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.createParser
+					.for("asset")
+					.tap(plugin, parserOptions => {
+						validate(getParserSchema(), parserOptions, {
+							name: "Asset Modules Plugin",
+							baseDataPath: "parser"
+						});
+						parserOptions = cleverMerge(
+							compiler.options.module.parser.asset,
+							parserOptions
+						);
+
+						let dataUrlCondition = parserOptions.dataUrlCondition;
+						if (!dataUrlCondition || typeof dataUrlCondition === "object") {
+							dataUrlCondition = {
+								maxSize: 8096,
+								...dataUrlCondition
+							};
+						}
+
+						const AssetParser = getAssetParser();
+
+						return new AssetParser(dataUrlCondition);
+					});
+				normalModuleFactory.hooks.createParser
+					.for("asset/inline")
+					.tap(plugin, parserOptions => {
+						const AssetParser = getAssetParser();
+
+						return new AssetParser(true);
+					});
+				normalModuleFactory.hooks.createParser
+					.for("asset/resource")
+					.tap(plugin, parserOptions => {
+						const AssetParser = getAssetParser();
+
+						return new AssetParser(false);
+					});
+				normalModuleFactory.hooks.createParser
+					.for("asset/source")
+					.tap(plugin, parserOptions => {
+						const AssetSourceParser = getAssetSourceParser();
+
+						return new AssetSourceParser();
+					});
+
+				for (const type of ["asset", "asset/inline", "asset/resource"]) {
+					normalModuleFactory.hooks.createGenerator
+						.for(type)
+						// eslint-disable-next-line no-loop-func
+						.tap(plugin, generatorOptions => {
+							validate(getGeneratorSchemaMap[type](), generatorOptions, {
+								name: "Asset Modules Plugin",
+								baseDataPath: "generator"
+							});
+
+							let dataUrl = undefined;
+							if (type !== "asset/resource") {
+								dataUrl = generatorOptions.dataUrl;
+								if (!dataUrl || typeof dataUrl === "object") {
+									dataUrl = {
+										encoding: "base64",
+										mimetype: undefined,
+										...dataUrl
+									};
+								}
+							}
+
+							let filename = undefined;
+							let publicPath = undefined;
+							if (type !== "asset/inline") {
+								filename = generatorOptions.filename;
+								publicPath = generatorOptions.publicPath;
+							}
+
+							const AssetGenerator = getAssetGenerator();
+
+							return new AssetGenerator(
+								dataUrl,
+								filename,
+								publicPath,
+								generatorOptions.emit !== false
+							);
+						});
+				}
+				normalModuleFactory.hooks.createGenerator
+					.for("asset/source")
+					.tap(plugin, () => {
+						const AssetSourceGenerator = getAssetSourceGenerator();
+
+						return new AssetSourceGenerator();
+					});
+
+				compilation.hooks.renderManifest.tap(plugin, (result, options) => {
+					const { chunkGraph } = compilation;
+					const { chunk, codeGenerationResults } = options;
+
+					const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
+						chunk,
+						"asset",
+						compareModulesByIdentifier
+					);
+					if (modules) {
+						for (const module of modules) {
+							const codeGenResult = codeGenerationResults.get(
+								module,
+								chunk.runtime
+							);
+							result.push({
+								render: () => codeGenResult.sources.get(type),
+								filename:
+									module.buildInfo.filename ||
+									codeGenResult.data.get("filename"),
+								info:
+									module.buildInfo.assetInfo ||
+									codeGenResult.data.get("assetInfo"),
+								auxiliary: true,
+								identifier: `assetModule${chunkGraph.getModuleId(module)}`,
+								hash:
+									module.buildInfo.fullContentHash ||
+									codeGenResult.data.get("fullContentHash")
+							});
+						}
+					}
+
+					return result;
+				});
+			}
+		);
+	}
+}
+
+module.exports = AssetModulesPlugin;

assets_old/node_modules/webpack/lib/asset/AssetParser.js

@@ -0,0 +1,56 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Yuta Hiroto @hiroppy
+*/
+
+"use strict";
+
+const Parser = require("../Parser");
+
+/** @typedef {import("../../declarations/WebpackOptions").AssetParserOptions} AssetParserOptions */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+
+class AssetParser extends Parser {
+	/**
+	 * @param {AssetParserOptions["dataUrlCondition"] | boolean} dataUrlCondition condition for inlining as DataUrl
+	 */
+	constructor(dataUrlCondition) {
+		super();
+		this.dataUrlCondition = dataUrlCondition;
+	}
+
+	/**
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		if (typeof source === "object" && !Buffer.isBuffer(source)) {
+			throw new Error("AssetParser doesn't accept preparsed AST");
+		}
+		state.module.buildInfo.strict = true;
+		state.module.buildMeta.exportsType = "default";
+
+		if (typeof this.dataUrlCondition === "function") {
+			state.module.buildInfo.dataUrl = this.dataUrlCondition(source, {
+				filename: state.module.matchResource || state.module.resource,
+				module: state.module
+			});
+		} else if (typeof this.dataUrlCondition === "boolean") {
+			state.module.buildInfo.dataUrl = this.dataUrlCondition;
+		} else if (
+			this.dataUrlCondition &&
+			typeof this.dataUrlCondition === "object"
+		) {
+			state.module.buildInfo.dataUrl =
+				Buffer.byteLength(source) <= this.dataUrlCondition.maxSize;
+		} else {
+			throw new Error("Unexpected dataUrlCondition type");
+		}
+
+		return state;
+	}
+}
+
+module.exports = AssetParser;

assets_old/node_modules/webpack/lib/asset/AssetSourceGenerator.js

@@ -0,0 +1,71 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sergey Melyukov @smelukov
+*/
+
+"use strict";
+
+const { RawSource } = require("webpack-sources");
+const Generator = require("../Generator");
+const RuntimeGlobals = require("../RuntimeGlobals");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../NormalModule")} NormalModule */
+
+const TYPES = new Set(["javascript"]);
+
+class AssetSourceGenerator extends Generator {
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
+	 */
+	generate(module, { chunkGraph, runtimeTemplate, runtimeRequirements }) {
+		runtimeRequirements.add(RuntimeGlobals.module);
+
+		const originalSource = module.originalSource();
+
+		if (!originalSource) {
+			return new RawSource("");
+		}
+
+		const content = originalSource.source();
+
+		let encodedSource;
+		if (typeof content === "string") {
+			encodedSource = content;
+		} else {
+			encodedSource = content.toString("utf-8");
+		}
+		return new RawSource(
+			`${RuntimeGlobals.module}.exports = ${JSON.stringify(encodedSource)};`
+		);
+	}
+
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return TYPES;
+	}
+
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		const originalSource = module.originalSource();
+
+		if (!originalSource) {
+			return 0;
+		}
+
+		// Example: m.exports="abcd"
+		return originalSource.size() + 12;
+	}
+}
+
+module.exports = AssetSourceGenerator;

assets_old/node_modules/webpack/lib/asset/AssetSourceParser.js

@@ -0,0 +1,31 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Yuta Hiroto @hiroppy
+*/
+
+"use strict";
+
+const Parser = require("../Parser");
+
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+
+class AssetSourceParser extends Parser {
+	/**
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		if (typeof source === "object" && !Buffer.isBuffer(source)) {
+			throw new Error("AssetSourceParser doesn't accept preparsed AST");
+		}
+		const { module } = state;
+		module.buildInfo.strict = true;
+		module.buildMeta.exportsType = "default";
+
+		return state;
+	}
+}
+
+module.exports = AssetSourceParser;