esbuild.js

const esbuild = require("esbuild");
const fs = require("fs");
const path = require("path");

const production = process.argv.includes('--production');
const watch = process.argv.includes('--watch');

/**
 * @type {import('esbuild').Plugin}
 */
const esbuildProblemMatcherPlugin = {
	name: 'esbuild-problem-matcher',

	setup(build) {
		build.onStart(() => {
			console.log('[watch] build started');
		});
		build.onEnd((result) => {
			result.errors.forEach(({ text, location }) => {
				console.error(`✘ [ERROR] ${text}`);
				console.error(`    ${location.file}:${location.line}:${location.column}:`);
			});
			
			// Copy HTML files and Monaco Editor assets to dist folder
			try {
				if (!fs.existsSync('dist')) {
					fs.mkdirSync('dist');
				}
				if (!fs.existsSync('dist/src')) {
					fs.mkdirSync('dist/src');
				}
				
				// Copy tabView.html
				const tabViewSrc = path.join('src', 'tabView.html');
				const tabViewDest = path.join('dist', 'src', 'tabView.html');
				
				if (fs.existsSync(tabViewSrc)) {
					fs.copyFileSync(tabViewSrc, tabViewDest);
				}
				
				// Copy trainingRecordForm.css
				const cssSrc = path.join('src', 'trainingRecordForm.css');
				const cssDest = path.join('dist', 'src', 'trainingRecordForm.css');
				
				if (fs.existsSync(cssSrc)) {
					fs.copyFileSync(cssSrc, cssDest);
				}

				// Copy Monaco Editor assets (CSS and fonts) for webview
				const monacoSrcDir = path.join('node_modules', 'monaco-editor', 'min', 'vs');
				const monacoDestDir = path.join('dist', 'monaco-editor', 'vs');
				
				if (fs.existsSync(monacoSrcDir)) {
					// Create monaco-editor directory structure
					if (!fs.existsSync(path.join('dist', 'monaco-editor'))) {
						fs.mkdirSync(path.join('dist', 'monaco-editor'));
					}
					if (!fs.existsSync(monacoDestDir)) {
						fs.mkdirSync(monacoDestDir, { recursive: true });
					}
					
					// Copy main Monaco CSS file
					const monacoCssSrc = path.join(monacoSrcDir, 'style.css');
					const monacoCssDest = path.join(monacoDestDir, 'style.css');
					
					if (fs.existsSync(monacoCssSrc)) {
						fs.copyFileSync(monacoCssSrc, monacoCssDest);
					}
					
					// Copy assets directory (web workers)
					const assetsSrcDir = path.join(monacoSrcDir, 'assets');
					const assetsDestDir = path.join(monacoDestDir, 'assets');
					
					if (fs.existsSync(assetsSrcDir)) {
						if (!fs.existsSync(assetsDestDir)) {
							fs.mkdirSync(assetsDestDir, { recursive: true });
						}
						
						// Copy all asset files
						const assetFiles = fs.readdirSync(assetsSrcDir);
						assetFiles.forEach(file => {
							fs.copyFileSync(
								path.join(assetsSrcDir, file),
								path.join(assetsDestDir, file)
							);
						});
					}
				}
			} catch (error) {
				console.error('Failed to copy static assets:', error);
			}
			
			console.log('[watch] Build finished');
		});
	},
};

async function createContext(options) {
	return esbuild.context({
		...options,
		logLevel: 'silent',
		plugins: [
			/* add to the end of plugins array */
			esbuildProblemMatcherPlugin,
			...(options.plugins || [])
		],
	});
}

async function main() {
	const extensionContext = await createContext({
		entryPoints: ['src/extension.ts'],
		bundle: true,
		format: 'cjs',
		minify: production,
		sourcemap: !production,
		sourcesContent: false,
		platform: 'node',
		outfile: 'dist/extension.js',
		external: ['vscode'],
	});

	const webviewContext = await createContext({
		entryPoints: ['src/webview/trainingRecordForm/main.ts'],
		bundle: true,
		format: 'esm',
		minify: production,
		sourcemap: !production,
		target: ['es2020'],
		platform: 'browser',
		outfile: 'dist/webview/trainingRecordForm/main.js',
		loader: {
			'.ttf': 'file',
			'.woff': 'file',
			'.woff2': 'file',
			'.eot': 'file',
			'.svg': 'file',
			'.css': 'css'
		},
		assetNames: 'assets/[name]-[hash][ext]'
	});

	const settingsWebviewContext = await createContext({
		entryPoints: ['src/webview/settingsView/main.ts'],
		bundle: true,
		format: 'esm',
		minify: production,
		sourcemap: !production,
		target: ['es2020'],
		platform: 'browser',
		outfile: 'dist/webview/settingsView/main.js',
		loader: {
			'.ttf': 'file',
			'.woff': 'file',
			'.woff2': 'file',
			'.eot': 'file',
			'.svg': 'file',
			'.css': 'css'
		},
		assetNames: 'assets/[name]-[hash][ext]'
	});

	if (watch) {
		await Promise.all([extensionContext.watch(), webviewContext.watch(), settingsWebviewContext.watch()]);
	} else {
		await Promise.all([extensionContext.rebuild(), webviewContext.rebuild(), settingsWebviewContext.rebuild()]);
		await Promise.all([extensionContext.dispose(), webviewContext.dispose(), settingsWebviewContext.dispose()]);
	}
}

main().catch(e => {
	console.error(e);
	process.exit(1);
});