@fontoxml/fontoxml-development-tools 3.9.0-beta.1 → 3.9.0-beta.2

package/src/modules/editor/src/webpackPlugins/CopyPlugin.js

@@ -1,269 +1,217 @@
-/** @typedef {import('webpack').Compiler} Compiler */
-
 import fastGlob from 'fast-glob';
 import fs from 'fs-extra';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import webpack from 'webpack';
 
 import normalisePath from '../helpers/normalisePath.js';
 
 const emittedAssets = new Map();
+const plugin = { name: 'CopyPlugin' };
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-/**
- * This plugin add assets to the compilation which do not exist in the
- * dependency tree ('assets' folders of packages).
- */
 export default class CopyPlugin {
 	constructor(options) {
 		this.options = options;
 	}
 
-	/**
-	 * @param {Compiler} compiler
-	 */
 	apply(compiler) {
 		let packageInfos;
 
-		compiler.hooks.thisCompilation.tap(CopyPlugin.name, (compilation) => {
-			compilation.hooks.additionalAssets.tapAsync(
-				CopyPlugin.name,
-				async (callback) => {
-					if (
-						compilation.packagesInfoInLoadOrderError ||
-						!compilation.packagesInfoInLoadOrder
-					) {
-						const error =
-							compilation.packagesInfoInLoadOrderError ||
-							new Error(
-								'Could not get package load order information.'
-							);
-						packageInfos = error.packageInfos || [];
-						compilation.errors.push(error);
-						return callback();
+		compiler.hooks.emit.tapAsync(plugin, async (compilation, callback) => {
+			if (
+				compilation.packagesInfoInLoadOrderError ||
+				!compilation.packagesInfoInLoadOrder
+			) {
+				const error =
+					compilation.packagesInfoInLoadOrderError ||
+					new Error('Could not get package load order information.');
+				packageInfos = error.packageInfos || [];
+				compilation.errors.push(error);
+				callback();
+				return;
+			}
+
+			const templatesPath = normalisePath(
+				path.resolve(__dirname, '..', 'templates')
+			);
+			const assetInfoByTargetPath = new Map();
+
+			// TODO: It's not stricly necessary to process these assets every (re)compile.
+			// TODO: Consider placing these assets somewhere where they're unlikely to cause conflicts.
+			(
+				await fastGlob(
+					[`${fastGlob.escapePath(templatesPath)}/assets/**/*`],
+					{
+						absolute: true,
+						stats: true,
 					}
-
-					const templatesPath = normalisePath(
-						path.resolve(__dirname, '..', 'templates')
-					);
-					const assetInfoByTargetPath = new Map();
-
-					// TODO: It's not stricly necessary to process these assets
-					// every (re)compile.
-					// TODO: Consider placing these assets somewhere where
-					// they're unlikely to cause conflicts.
-					(
-						await fastGlob(
-							[
-								`${fastGlob.escapePath(
-									templatesPath
-								)}/assets/**/*`,
-							],
-							{
-								absolute: true,
-								stats: true,
-							}
+				)
+			).forEach((globResult) => {
+				assetInfoByTargetPath.set(
+					normalisePath(
+						path.relative(templatesPath, globResult.path)
+					),
+					{
+						path: globResult.path,
+						stats: globResult.stats,
+					}
+				);
+			});
+
+			if (this.options.unitTest) {
+				const testAssetsPath = normalisePath(
+					path.resolve(this.options.paths.contextFolder)
+				);
+				(
+					await fastGlob(
+						[
+							`${fastGlob.escapePath(
+								testAssetsPath
+							)}/test/assets/**/*`,
+						],
+						{
+							absolute: true,
+							stats: true,
+						}
+					)
+				).forEach((globResult) => {
+					const targetPath = normalisePath(
+						path.relative(
+							path.join(this.options.paths.contextFolder, 'test'),
+							globResult.path
 						)
-					).forEach((globResult) => {
-						assetInfoByTargetPath.set(
-							normalisePath(
-								path.relative(templatesPath, globResult.path)
-							),
-							{
-								path: globResult.path,
-								stats: globResult.stats,
-							}
-						);
+					);
+					assetInfoByTargetPath.set(targetPath, {
+						path: globResult.path,
+						stats: globResult.stats,
 					});
-
-					if (this.options.unitTest) {
-						const testAssetsPath = normalisePath(
-							path.resolve(this.options.paths.contextFolder)
-						);
-						(
-							await fastGlob(
-								[
-									`${fastGlob.escapePath(
-										testAssetsPath
-									)}/test/assets/**/*`,
-								],
-								{
-									absolute: true,
-									stats: true,
-								}
-							)
-						).forEach((globResult) => {
-							const targetPath = normalisePath(
-								path.relative(
-									path.join(
-										this.options.paths.contextFolder,
-										'test'
-									),
-									globResult.path
-								)
-							);
-							assetInfoByTargetPath.set(targetPath, {
-								path: globResult.path,
-								stats: globResult.stats,
-							});
+				});
+			}
+
+			packageInfos = compilation.packagesInfoInLoadOrder;
+
+			(
+				await Promise.all(
+					packageInfos.map(async (packageInfo) => {
+						const glob =
+							fastGlob.escapePath(
+								normalisePath(packageInfo.path)
+							) +
+							(packageInfo.name === 'config'
+								? '/assets/**/*'
+								: '/src/assets/**/*');
+
+						return await fastGlob([glob], {
+							absolute: true,
+							stats: true,
 						});
-					}
-
-					packageInfos = compilation.packagesInfoInLoadOrder;
-
-					(
-						await Promise.all(
-							packageInfos.map(async (packageInfo) => {
-								const glob =
-									fastGlob.escapePath(
-										normalisePath(packageInfo.path)
-									) +
-									(packageInfo.name === 'config'
-										? '/assets/**/*'
-										: '/src/assets/**/*');
-
-								return await fastGlob([glob], {
-									absolute: true,
-									stats: true,
-								});
-							})
+					})
+				)
+			).reduce((map, globResults) => {
+				globResults.forEach((globResult) => {
+					const relativePath = normalisePath(
+						path.relative(
+							this.options.paths.contextFolder,
+							globResult.path
 						)
-					).reduce((map, globResults) => {
-						globResults.forEach((globResult) => {
-							const relativePath = normalisePath(
-								path.relative(
-									this.options.paths.contextFolder,
-									globResult.path
-								)
-							);
-							const pathParts = relativePath.split(
-								path.posix.sep
-							);
-							const isRootPackage =
-								relativePath.startsWith('config') ||
-								(this.options.unitTest &&
-									relativePath.startsWith('src/'));
-							const targetPath = path.posix.join(
-								...pathParts.slice(isRootPackage ? 1 : 3)
-							);
-
-							map.set(targetPath, {
-								path: globResult.path,
-								stats: globResult.stats,
-							});
-						});
+					);
+					const pathParts = relativePath.split(path.posix.sep);
+					const isRootPackage =
+						relativePath.startsWith('config') ||
+						(this.options.unitTest &&
+							relativePath.startsWith('src/'));
+					const targetPath = path.posix.join(
+						...pathParts.slice(isRootPackage ? 1 : 3)
+					);
 
-						return map;
-					}, assetInfoByTargetPath);
+					map.set(targetPath, {
+						path: globResult.path,
+						stats: globResult.stats,
+					});
+				});
 
-					await Promise.all(
-						[...emittedAssets.keys()].map(async (targetPath) => {
-							if (!assetInfoByTargetPath.has(targetPath)) {
-								const assetOutputPath = path.join(
-									compilation.getPath(compiler.outputPath),
-									targetPath
-								);
+				return map;
+			}, assetInfoByTargetPath);
 
-								await new Promise((resolve, reject) =>
-									compiler.outputFileSystem.unlink(
-										assetOutputPath,
-										(error) =>
-											error ? reject(error) : resolve()
-									)
-								);
+			await Promise.all(
+				[...emittedAssets.keys()].map(async (targetPath) => {
+					if (!assetInfoByTargetPath.has(targetPath)) {
+						const assetOutputPath = path.join(
+							compilation.getPath(compiler.outputPath),
+							targetPath
+						);
 
-								emittedAssets.delete(targetPath);
-							}
-						})
-					);
+						await new Promise((resolve, reject) =>
+							compiler.outputFileSystem.unlink(
+								assetOutputPath,
+								(error) => (error ? reject(error) : resolve())
+							)
+						);
 
-					await Promise.all(
-						[...assetInfoByTargetPath.keys()].map(
-							async (targetPath) => {
-								const assetInfo =
-									assetInfoByTargetPath.get(targetPath);
+						emittedAssets.delete(targetPath);
+					}
+				})
+			);
 
-								if (
-									emittedAssets.has(targetPath) &&
-									emittedAssets.get(targetPath).path ===
-										assetInfo.path &&
-									emittedAssets.get(targetPath).stats
-										.mtimeMs === assetInfo.stats.mtimeMs
-								) {
-									return;
-								}
+			await Promise.all(
+				[...assetInfoByTargetPath.keys()].map(async (targetPath) => {
+					const assetInfo = assetInfoByTargetPath.get(targetPath);
 
-								emittedAssets.set(targetPath, assetInfo);
+					if (
+						emittedAssets.has(targetPath) &&
+						emittedAssets.get(targetPath).path === assetInfo.path &&
+						emittedAssets.get(targetPath).stats.mtimeMs ===
+							assetInfo.stats.mtimeMs
+					) {
+						return;
+					}
 
-								const content = await fs.readFile(
-									assetInfo.path
-								);
+					emittedAssets.set(targetPath, assetInfo);
 
-								compilation.emitAsset(
-									targetPath,
-									new webpack.sources.RawSource(content)
-								);
-							}
-						)
-					);
+					const content = await fs.readFile(assetInfo.path);
 
-					return callback();
-				}
+					compilation.assets[targetPath] = {
+						size() {
+							return assetInfo.stats.size;
+						},
+						source() {
+							return content;
+						},
+					};
+				})
 			);
 
-			compiler.hooks.afterEmit.tapAsync(
-				CopyPlugin.name,
-				async (compilation, callback) => {
-					const platformPath = path.normalize(
-						this.options.paths.platformFolder
-					);
+			callback();
+		});
+
+		compiler.hooks.afterEmit.tapAsync(plugin, (compilation, callback) => {
+			const platformPath = path.normalize(
+				this.options.paths.platformFolder
+			);
 
-					await Promise.all(
-						packageInfos.map(async (packageInfo) => {
-							const packagePath = path.normalize(
-								packageInfo.path
-							);
+			// TODO: Consider checking if the assets folder/manifest file exists before watching.
+			packageInfos.forEach((packageInfo) => {
+				const packagePath = path.normalize(packageInfo.path);
 
-							if (
-								packagePath ===
-								path.join(platformPath, packageInfo.name)
-							) {
-								return;
-							}
+				if (packagePath === path.join(platformPath, packageInfo.name)) {
+					return;
+				}
 
-							compilation.contextDependencies.add(
-								path.join(
-									packagePath,
-									packageInfo.name === 'config' ? '' : 'src'
-								)
-							);
+				compilation.contextDependencies.add(
+					path.join(
+						packagePath,
+						packageInfo.name === 'config' ? 'assets' : 'src/assets'
+					)
+				);
 
-							const fontoManifestPath = path.join(
-								packagePath,
-								'fonto-manifest.json'
-							);
-							const exists = await fs
-								.access(fontoManifestPath)
-								.then(() => true)
-								.catch(() => false);
-							if (exists) {
-								compilation.fileDependencies.add(
-									fontoManifestPath
-								);
-							} else {
-								compilation.missingDependencies.add(
-									fontoManifestPath
-								);
-							}
-						})
-					);
+				compilation.fileDependencies.add(
+					path.join(packagePath, 'fonto-manifest.json')
+				);
+			});
 
-					return callback();
-				}
-			);
+			callback();
 		});
 	}
 }

package/src/modules/editor/src/webpackPlugins/DependenciesInLoadOrderPlugin.js

@@ -1,24 +1,15 @@
-/** @typedef {import('webpack').Compiler} Compiler */
-
 import getDependenciesInLoadOrder from '../getDependenciesInLoadOrder.js';
 
-/**
- * This plugin exposes Fonto Editor's dependency tree through webpack's
- * compilation objects for use by other plugins.
- */
 export default class DependenciesInLoadOrderPlugin {
 	constructor(options) {
 		this.options = options;
 	}
 
-	/**
-	 * @param {Compiler} compiler
-	 */
 	apply(compiler) {
 		// Listen to thisCompilation hook and get dependencies in load order once per compilation.
 		compiler.hooks.thisCompilation.tap(
-			DependenciesInLoadOrderPlugin.name,
-			(compilation) => {
+			'DependenciesInLoadOrderPlugin',
+			(compilation, _compilationParams) => {
 				try {
 					const packageRootFolders =
 						this.options.paths.packageRootFolders;