sdc-build-wp 4.9.2 → 5.0.1

package/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { default as project, init, keypressListen } from './lib/project.js';
-import build from './lib/build.js';
+import { build } from './lib/build.js';
 
 (async () => {
 	await init();

package/lib/build.js

@@ -2,7 +2,7 @@ import { default as project } from './project.js';
 import * as utils from './utils.js';
 import log from './logging.js';
 
-export default async function(watch = false) {
+export async function build(watch = false) {
 	if (project.components.cache && project.builds.includes('cache')) {
 		try {
 			await project.components.cache.init();
@@ -62,3 +62,11 @@ export default async function(watch = false) {
 		process.emit('SIGINT');
 	}
 }
+
+export function restartBuild() {
+	utils.stopActiveComponents();
+	setTimeout(() => {
+		utils.clearScreen();
+		build(true);
+	}, 100);
+}

package/lib/components/blocks.js

@@ -37,10 +37,10 @@ export default class BlocksComponent extends BaseComponent {
 
 			for (const file of srcFiles) {
 				if (/\.(js|jsx|ts|tsx)$/.test(file)) {
-					const jsDependencies = this.utils.getAllJSDependencies(file);
+					const jsDependencies = await this.utils.getAllJSDependencies(file);
 					dependencies.push(...jsDependencies);
 				} else if (/\.(scss|sass)$/.test(file)) {
-					const scssDependencies = this.utils.getImportedSASSFiles(file);
+					const scssDependencies = await this.utils.getImportedSASSFiles(file);
 					dependencies.push(...scssDependencies);
 				}
 			}

package/lib/components/fonts.js

@@ -11,7 +11,7 @@ export default class FontsComponent extends BaseComponent {
 
 	async init() {
 		this.globs = await Array.fromAsync(
-			this.glob(this.project.package?.sdc?.fontsPath ||
+			this.glob(this.project.config.fontsPath ||
 			`${this.project.path}/${this.project.paths.src.src}/${this.project.paths.src.fonts}`)
 		);
 		await this.process();

package/lib/components/images.js

@@ -13,7 +13,7 @@ export default class ImagesComponent extends BaseComponent {
 
 	async init() {
 		this.globs = await Array.fromAsync(
-			this.glob(this.project.package?.sdc?.imagesPath ||
+			this.glob(this.project.config.imagesPath ||
 			`${this.project.paths.images}/**/*`)
 		);
 		this.globsDirectories = [

package/lib/components/php.js

@@ -12,7 +12,7 @@ export default class PHPComponent extends BaseComponent {
 
 	async init() {
 		this.globs = await Array.fromAsync(
-			this.glob(this.project.package?.sdc?.phpGlobPath ||
+			this.glob(this.project.config.phpGlobPath ||
 			`${this.project.path}/**/*.php`)
 		);
 		// await this.process(null, { lintType: 'warn' }); // this errors "Fatal error: Allowed memory size"

package/lib/components/scripts.js

@@ -14,7 +14,7 @@ export default class ScriptsComponent extends BaseComponent {
 	async init() {
 		this.files = this.utils.addEntriesByFiletypes(['.js', '.jsx', '.ts', '.tsx']);
 		this.globs = await Array.fromAsync(
-			this.glob(this.project.package?.sdc?.scriptsGlobPath ||
+			this.glob(this.project.config.scriptsGlobPath ||
 			`${this.project.path}/${this.project.paths.src.src}/${this.project.paths.src.scripts}/**/*.{js,jsx,ts,tsx}`)
 		);
 		await this.process();
@@ -35,12 +35,12 @@ export default class ScriptsComponent extends BaseComponent {
 				throw thisLint;
 			}
 		} catch (error) {
-			console.log(error);
+			console.error(error);
 			this.log('error', `Failed linting ${entry.replace(`${this.project.path}/${this.project.paths.src.src}/${this.project.paths.src.scripts}/`, '')} - See above error.`);
 			return false;
 		}
 
-		const dependencies = this.utils.getAllJSDependencies(entry);
+		const dependencies = await this.utils.getAllJSDependencies(entry);
 
 		this.clearHashCache([entry, ...(options.entriesToLint || []), ...dependencies]);
 
@@ -116,6 +116,7 @@ export default class ScriptsComponent extends BaseComponent {
 			if (formatterOutput) { console.log(formatterOutput.replace(`${this.project.path}/${this.project.paths.src.src}/${this.project.paths.src.scripts}/`, '')); }
 			return true;
 		} catch (error) {
+			console.error(error);
 			return error;
 		}
 	}

package/lib/components/server.js

@@ -11,14 +11,7 @@ export default class ServerComponent extends BaseComponent {
 		this.description = `Run a dev proxy server for live reloading`;
 		this.sessions = {};
 		this.server = create('SDC WP Build Server');
-		this.watchedFiles = [
-			`${this.project.paths.dist}/**/*`,
-			`**/*.html`,
-			`**/*.json`
-		];
-		if (!this.project.shouldPHPLint) {
-			this.watchedFiles.push(`**/*.php`);
-		}
+		this.watchedFiles = [];
 		this.ignoredFiles = [
 			`.sdc-build-wp/cache/**`,
 			`node_modules/**`,
@@ -28,6 +21,14 @@ export default class ServerComponent extends BaseComponent {
 	}
 
 	async init() {
+		this.watchedFiles = [
+			`${this.project.paths.dist}/**/*`,
+			`**/*.html`,
+			`**/*.json`
+		];
+		if (!this.project.config.php.enabled) {
+			this.watchedFiles.push(`**/*.php`);
+		}
 		this.project.pageScript = await readFile(path.join(path.dirname(fileURLToPath(import.meta.url)), '../page-script.js'), 'utf8');
 	}
 
@@ -37,8 +38,8 @@ export default class ServerComponent extends BaseComponent {
 		let bsOptions = {
 			logPrefix: '',
 			logFileChanges: false,
-			port: this.project.package.sdc?.port || 3000,
-			proxy: this.project.package.sdc?.browsersync?.localProxyURL,
+			port: this.project.config.port || 3000,
+			proxy: this.project.config.browsersync?.localProxyURL,
 			files: watch ? this.watchedFiles : [],
 			watchOptions: {
 				cwd: this.project.path,
@@ -48,14 +49,14 @@ export default class ServerComponent extends BaseComponent {
 			reloadDelay: 250,
 			reloadDebounce: 1000,
 			reloadOnRestart: true,
-			watchEvents: this.project.package.sdc?.browsersync?.watchEvents || ['add', 'change', 'unlink', 'addDir', 'unlinkDir'],
-			open: this.project.package.sdc?.open || false,
+			watchEvents: this.project.config.browsersync?.watchEvents || ['add', 'change', 'unlink', 'addDir', 'unlinkDir'],
+			open: this.project.config.browsersync?.open || false,
 			https: (process.env.SSL_KEY_PATH && process.env.SSL_CRT_PATH ? {
 				key: process.env.SSL_KEY_PATH,
 				cert: process.env.SSL_CRT_PATH
 			} : false),
 			ui: false,
-			tunnel: this.project.package.sdc?.browsersync?.tunnel,
+			tunnel: this.project.config.browsersync?.tunnel,
 			notify: {
 				styles: {
 					pointerEvents: 'none',
@@ -68,11 +69,11 @@ export default class ServerComponent extends BaseComponent {
 			},
 			snippetOptions: {
 				rule: {
-					match: thisProject.package.sdc?.browsersync?.location == 'end' ? /<\/body>/ : /<body[^>]*>/,
+					match: thisProject.config.browsersync?.location == 'end' ? /<\/body>/ : /<body[^>]*>/,
 					fn: function (snippet, match) {
 						const customScript = `<script async>${thisProject.pageScript}</script>`;
 						const allScripts = snippet + customScript;
-						return thisProject.package.sdc?.browsersync?.location == 'end' ? allScripts + match : match + allScripts;
+						return thisProject.config.browsersync?.location == 'end' ? allScripts + match : match + allScripts;
 					}
 				}
 			}

package/lib/components/style.js

@@ -17,7 +17,7 @@ export default class StyleComponent extends BaseComponent {
 	async init() {
 		this.files = this.utils.addEntriesByFiletypes(['.scss']);
 		this.globs = await Array.fromAsync(
-			this.glob(this.project.package?.sdc?.sassGlobPath ||
+			this.glob(this.project.config.sassGlobPath ||
 			`${this.project.path}{/${this.project.paths.src.src}/${this.project.paths.src.style},/blocks}/**/*.scss`)
 		);
 		await this.process();
@@ -129,7 +129,7 @@ export default class StyleComponent extends BaseComponent {
 
 			this.clearHashCache([entry, ...(options.entriesToLint || [])]);
 
-			const sassDependencies = this.utils.getImportedSASSFiles(entry);
+			const sassDependencies = await this.utils.getImportedSASSFiles(entry);
 			if (await this.shouldSkipBuild(entry, outFile, sassDependencies)) {
 				this.end({
 					itemLabel: entryLabel,
@@ -202,7 +202,7 @@ export default class StyleComponent extends BaseComponent {
 			try {
 				let hasRanSingle = false;
 				for (let group of this.files) {
-					if (path == group.file || this.utils.getImportedSASSFiles(group.file).includes(path)) {
+					if (path == group.file || (await this.utils.getImportedSASSFiles(group.file)).includes(path)) {
 						await this.process(group.file, { buildTheme: path == this.project.paths.theme.json });
 						hasRanSingle = true;
 					}

package/lib/config-validator.js

@@ -0,0 +1,104 @@
+import log from './logging.js';
+
+const configSchema = {
+	imagesPath: { type: 'string', optional: true },
+	errorLogPath: { type: 'string', optional: true },
+	entries: { type: 'object', optional: true },
+	php: {
+		type: 'object',
+		optional: true,
+		properties: {
+			enabled: { type: 'boolean', optional: true }
+		}
+	}
+};
+
+function validateType(value, expectedType, path = '') {
+	const actualType = Array.isArray(value) ? 'array' : typeof value;
+	if (actualType !== expectedType) {
+		throw new Error(`Configuration error at '${path}': expected ${expectedType}, got ${actualType}`);
+	}
+}
+
+function validateObject(obj, schema, path = '') {
+	if (!obj || typeof obj !== 'object') {
+		if (!schema.optional) {
+			throw new Error(`Configuration error at '${path}': expected object, got ${typeof obj}`);
+		}
+		return;
+	}
+
+	const allowedKeys = Object.keys(schema.properties || {});
+	const objKeys = Object.keys(obj);
+	const unknownKeys = objKeys.filter(key => !allowedKeys.includes(key));
+
+	if (unknownKeys.length > 0) {
+		log('warn', `Unknown configuration properties: ${unknownKeys.map(key => `${path}.${key}`).join(', ')}`);
+	}
+
+	for (const [key, subSchema] of Object.entries(schema.properties || {})) {
+		const currentPath = path ? `${path}.${key}` : key;
+		const value = obj[key];
+
+		if (value === undefined || value === null) {
+			if (!subSchema.optional) {
+				throw new Error(`Configuration error: required property '${currentPath}' is missing`);
+			}
+			continue;
+		}
+
+		if (subSchema.type === 'object' && subSchema.properties) {
+			validateObject(value, subSchema, currentPath);
+		} else {
+			validateType(value, subSchema.type, currentPath);
+		}
+	}
+}
+
+function validateConfig(config) {
+	try {
+		for (const [key, schema] of Object.entries(configSchema)) {
+			const value = config[key];
+			const currentPath = key;
+
+			if (value === undefined || value === null) {
+				if (!schema.optional) {
+					throw new Error(`Configuration error: required property '${currentPath}' is missing`);
+				}
+				continue;
+			}
+
+			if (schema.type === 'object' && schema.properties) {
+				validateObject(value, schema, currentPath);
+			} else {
+				validateType(value, schema.type, currentPath);
+			}
+		}
+		return true;
+	} catch (error) {``
+		console.error(error);
+		log('error', `Configuration validation failed`);
+		return false;
+	}
+}
+
+function getDefaultConfig() {
+	return {
+		errorLogPath: '../../../../../logs/php/error.log', // default Local by Flywheel error log path
+		php: {
+			enabled: true
+		}
+	};
+}
+
+function mergeWithDefaults(userConfig) {
+	const defaults = getDefaultConfig();
+
+	return {
+		...defaults,
+		...userConfig,
+		php: { ...defaults.php, ...userConfig.php }
+	};
+}
+
+export { validateConfig, getDefaultConfig, mergeWithDefaults };

package/lib/help.js

@@ -1,34 +1,48 @@
 import project from './project.js';
+import chalk from 'chalk';
 
 export default function() {
 	console.log(`
-Usage: sdc-build-wp [options] [arguments]
+${chalk.bold.blue('SDC Build WP')} - Custom WordPress build process
 
-Options:
-	-h, --help           Show help message and exit
-	-v, --version        Version
-	-w, --watch          Build and watch
-	-b, --builds BUILDS  Build with specific components
-	--no-cache           Disable build caching
-	--clear-cache        Clear build cache and exit
+${chalk.yellow('Usage:')} sdc-build-wp [options] [arguments]
 
-Components:
+${chalk.yellow('Options:')}
+  ${chalk.green('-h, --help')}           Show this help message and exit
+  ${chalk.green('-v, --version')}        Show version number and exit
+  ${chalk.green('-w, --watch')}          Build and watch for changes
+  ${chalk.green('-b, --builds BUILDS')}  Build with specific components (comma-separated)
+  ${chalk.green('--no-cache')}           Disable build caching for this run
+  ${chalk.green('--clear-cache')}        Clear all cached data and exit
 
+${chalk.yellow('Available Components:')}
 ${Object.entries(project.components).map(([key, component]) => {
-	return `${key}\t\t${component.description}\r\n`;
-}).join('')}
-Examples:
+		return `  ${chalk.cyan(key.padEnd(12))} ${component.description}`;
+	}).join('\n')}
 
-sdc-build-wp
-sdc-build-wp --watch
-sdc-build-wp --watch --builds=style,scripts
-sdc-build-wp --no-cache
-sdc-build-wp --clear-cache
+${chalk.yellow('Examples:')}
+  ${chalk.dim('# Basic build')}
+  sdc-build-wp
 
-While watch is enabled, use the following keyboard commands to control the build process:
+  ${chalk.dim('# Build and watch for changes')}
+  sdc-build-wp --watch
 
-	[r]     Restart
-	[p]     Pause/Resume
-	[q]     Quit
+  ${chalk.dim('# Build only specific components')}
+  sdc-build-wp --watch --builds=style,scripts
+
+  ${chalk.dim('# Build without cache')}
+  sdc-build-wp --no-cache
+
+  ${chalk.dim('# Clear cache and exit')}
+  sdc-build-wp --clear-cache
+
+${chalk.yellow('Watch Mode Controls:')}
+  ${chalk.green('[r]')} Restart build process
+  ${chalk.green('[p]')} Pause/Resume watching
+  ${chalk.green('[q]')} Quit and exit
+
+${chalk.yellow('Configuration:')}
+  Place your configuration in ${chalk.cyan('.sdc-build-wp/config.json')}
+  See documentation for available options.
 `);
 }

package/lib/project.js

@@ -1,12 +1,18 @@
-import parseArgs from 'minimist';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
 import { readFile } from 'fs/promises';
-import build from './build.js';
+import path from 'path';
+import { promises as fs } from 'fs';
+import chokidar from 'chokidar';
+import { restartBuild } from './build.js';
 import * as utils from './utils.js';
 import log from './logging.js';
 import * as LibComponents from './components/index.js';
 import help from './help.js';
+import { validateConfig, mergeWithDefaults } from './config-validator.js';
 
 let project = {
+	config: {},
 	argv: null,
 	isRunning: false,
 	path: process.cwd(),
@@ -21,7 +27,7 @@ let project = {
 	}
 };
 
-project.shouldPHPLint = typeof project.package.sdc?.php === 'undefined' || typeof project.package.sdc?.php.enabled === 'undefined' || project.package.sdc?.php.enabled == true;
+const configPath = path.join(project.path, '.sdc-build-wp', 'config.json');
 
 project.paths = {
 	src: {
@@ -44,8 +50,8 @@ project.paths = {
 	composer: {
 		vendor: `${project.path}/vendor`
 	},
-	images: project.package?.sdc?.imagesPath || `${project.path}/${project.paths.src.src}/${project.paths.src.images}`,
-	errorLog: process.env.ERROR_LOG_PATH || project.package.sdc?.error_log_path || '../../../../../logs/php/error.log'
+	images: null,
+	errorLog: null
 };
 
 project.chokidarOpts = {
@@ -58,42 +64,41 @@ project.chokidarOpts = {
 		`${project.paths.composer.vendor}/**/*`,
 		project.paths.theme.scss,
 		`${project.path}/blocks/*/build/*.php`,
-		`${project.path}/.sdc-build-wp/**/*`,
+		`${project.path}/.sdc-build-wp/cache/**/*`,
 	]
 };
 
-export default project;
-
 export async function init() {
-	project.argv = parseArgs(process.argv.slice(2));
+
 	project.components = Object.fromEntries(Object.entries(LibComponents).map(([name, Class]) => [name, new Class()]));
 
-	process.on('unhandledRejection', (reason, promise) => {
-		log('error', `Unhandled Promise Rejection: ${reason}`);
-		log('warn', 'Continuing build process despite error');
-	});
-
-	process.on('uncaughtException', (error) => {
-		log('error', `Uncaught Exception: ${error.message}`);
-		log('warn', 'Attempting graceful shutdown');
-		utils.stopActiveComponents();
-		process.exit(1);
-	});
+	project.argv = yargs(hideBin(process.argv))
+		.help(false)
+		.argv;
 
 	if (project.argv.help || project.argv.h) {
 		help();
 		process.exit(0);
-	} else if (project.argv.version || project.argv.v) {
+	}
+
+	if (project.package.sdc) {
+		await convertPackageToConfig();
+	}
+
+	await loadConfig();
+
+	const styleDir = `${project.path}/${project.paths.src.src}/${project.paths.src.style}`;
+
+	if (project.argv.version || project.argv.v) {
 		console.log(await utils.getThisPackageVersion());
 		process.exit(0);
 	} else if (project.argv['clear-cache']) {
-		if (project.components.cache) {
-			try {
-				await project.components.cache.init();
-				await project.components.cache.clearCache();
-			} catch (error) {
-				console.log(`Error clearing cache: ${error.message}`);
-			}
+		try {
+			await project.components.cache.init();
+			await project.components.cache.clearCache();
+		} catch (error) {
+			console.error(error);
+			log('error', `Failed to clear cache`);
 		}
 		process.exit(0);
 	}
@@ -112,13 +117,50 @@ export async function init() {
 		project.builds.unshift('cache');
 	}
 
-	process.on('SIGINT', function () {
+	if (Object.keys(project.entries).length === 0) {
+		const styleFiles = await utils.getAllFiles(styleDir, ['.scss', '.css']);
+		const jsFiles = await utils.getAllFiles(`${project.path}/${project.paths.src.src}/${project.paths.src.scripts}`, ['.js', '.ts']);
+		for (const file of [...styleFiles, ...jsFiles]) {
+			let thisFiletype = path.extname(file);
+			let replaceString;
+			if (['.scss', '.css'].includes(thisFiletype)) {
+				replaceString = project.paths.src.style;
+			} else if (['.js', '.ts'].includes(thisFiletype)) {
+				replaceString = project.paths.src.scripts;
+			}
+			if (!replaceString) {
+				continue;
+			}
+			const entryName = utils.entryBasename(file).replace(/\.(css|scss|js|ts)$/, '')
+			if (!project.entries[`${replaceString}/${entryName}`]) {
+				project.entries[`${replaceString}/${entryName}`] = [ file.replace(project.path, '') ];
+			}
+		}
+	}
+
+	process.on('unhandledRejection', (reason, promise) => {
+		log('error', `Unhandled Promise Rejection: ${reason}`);
+		log('warn', 'Continuing build process despite error');
+	});
+
+	process.on('uncaughtException', (error) => {
+		log('error', `Uncaught Exception: ${error.message}`);
+		log('warn', 'Attempting graceful shutdown');
+		utils.stopActiveComponents();
+		process.exit(1);
+	});
+
+	process.on('SIGINT', async function() {
 		console.log(`\r`);
 		if (project.isRunning) {
 			utils.stopActiveComponents();
 			project.isRunning = false;
 			utils.clearScreen();
 		}
+		if (project.configWatcher) {
+			await project.configWatcher.close();
+			project.configWatcher = null;
+		}
 		log('info', `Exited sdc-build-wp`);
 		if (process.stdin.isTTY) {
 			process.stdin.setRawMode(false);
@@ -138,7 +180,10 @@ export function keypressListen() {
 
 	process.stdin.on('data', (key) => {
 		switch (key) {
-			case '\u0003': // Ctrl+C
+			case '\r': // [Enter]/[Return]
+				console.log('\r');
+				break;
+			case '\u0003': // [Ctrl]+C
 			case 'q':
 				process.emit('SIGINT');
 				return;
@@ -153,12 +198,69 @@ export function keypressListen() {
 				break;
 			case 'r':
 				log('info', 'Restarted build process');
-				utils.stopActiveComponents();
-				setTimeout(() => {
-					utils.clearScreen();
-					build(true);
-				}, 100);
+				restartBuild();
 				break;
 		}
 	});
 }
+
+export async function convertPackageToConfig() {
+	if (!project.package.sdc) { return; }
+	try {
+		await fs.writeFile(configPath, JSON.stringify(project.package.sdc, null, '\t'));
+		log('success', 'Converted package.json sdc to .sdc-build-wp/config.json');
+		delete project.package.sdc;
+		await fs.writeFile(path.join(project.path, 'package.json'), JSON.stringify(project.package, null, '\t'));
+		log('success', 'Updated package.json to remove sdc');
+	} catch (error) {
+		log('error', `Failed to convert package.json sdc to .sdc-build-wp/config.json: ${error.message}`);
+		process.exit(1);
+	}
+}
+
+export async function loadConfig() {
+	try {
+		const configFile = await fs.readFile(configPath, 'utf-8');
+		const rawConfig = JSON.parse(configFile);
+		if (!validateConfig(rawConfig)) {
+			log('error', 'Configuration validation failed');
+			process.exit(1);
+		}
+		project.config = mergeWithDefaults(rawConfig);
+		project.paths.images = project.config.imagesPath || `${project.path}/${project.paths.src.src}/${project.paths.src.images}`;
+		project.paths.errorLog = project.config.errorLogPath;
+		project.entries = project.config.entries || {};
+		setupConfigWatcher();
+	} catch (error) {
+		if (error.code === 'ENOENT') {
+			log('warn', 'No config file found, using defaults');
+			project.config = mergeWithDefaults({});
+			project.paths.images = `${project.path}/${project.paths.src.src}/${project.paths.src.images}`;
+			project.entries = {};
+		} else {
+			console.error(error);
+			log('error', `Failed to load config: ${error.message}`);
+			process.exit(1);
+		}
+	}
+}
+
+export function setupConfigWatcher() {
+	if (!project.argv.watch) { return; }
+	const configWatcher = chokidar.watch(configPath, {
+		ignoreInitial: true,
+		persistent: true
+	});
+	configWatcher.on('change', async () => {
+		if (!project.isRunning) { return; }
+		await loadConfig();
+		restartBuild();
+	});
+	configWatcher.on('error', (error) => {
+		console.error(error);
+		log('warn', `Config file watcher error`);
+	});
+	project.configWatcher = configWatcher;
+}
+
+export default project;

package/lib/utils.js

@@ -1,12 +1,11 @@
 import path from 'path';
-import fs from 'fs';
-import * as fsPromises from 'fs/promises';
+import { promises as fs } from 'fs';
 import { readdir } from 'node:fs/promises';
 import { fileURLToPath } from 'url';
 import project from './project.js';
 
 export async function getThisPackageVersion() {
-	return JSON.parse(await fsPromises.readFile(path.join(path.dirname(fileURLToPath(import.meta.url)), '../package.json'))).version
+	return JSON.parse(await fs.readFile(path.join(path.dirname(fileURLToPath(import.meta.url)), '../package.json'))).version
 }
 
 export function clearScreen() {
@@ -15,14 +14,26 @@ export function clearScreen() {
 }
 
 export function stopActiveComponents() {
+	if (project.configWatcher) {
+		try {
+			project.configWatcher.close();
+		} catch (error) {
+			console.error(error);
+			log('error', 'Failed to stop config file watcher');
+		}
+	}
 	if (project.components.server?.server) {
 		try {
 			project.components.server.server.exit();
 		} catch (error) {
-			console.warn('Failed to stop server:', error.message);
+			console.error(error);
+			log('error', 'Failed to stop server');
 		}
 	}
-	Object.values(project.components).forEach(component => {
+	for (const component of Object.values(project.components)) {
+		if (component.isBuilding) {
+			component.isBuilding = false;
+		}
 		if (component.watcher) {
 			try {
 				component.watcher.close();
@@ -30,9 +41,6 @@ export function stopActiveComponents() {
 				console.warn(`Failed to stop watcher for ${component.constructor.name}:`, error.message);
 			}
 		}
-	});
-	if (project.components.scripts) {
-		project.components.scripts.isBuilding = false;
 	}
 }
 
@@ -44,6 +52,24 @@ export function entryBasename(entry) {
 	return path.parse(entry).base;
 }
 
+export async function getAllFiles(dir, filetypes = false) {
+	let files = [];
+	const entries = await readdir(dir, { withFileTypes: true });
+	if (filetypes && !Array.isArray(filetypes)) {
+		filetypes = [filetypes];
+	}
+	for (const entry of entries) {
+		const fullPath = path.join(dir, entry.name);
+		if (
+			!entry.isDirectory() &&
+			(!filetypes || filetypes.length == 0 || filetypes.includes(path.extname(fullPath)))
+		) {
+			files.push(fullPath);
+		}
+	}
+	return files;
+}
+
 export async function getAllSubdirectories(dir) {
 	let subdirectories = [];
 	const subdirectoriesEntries = await readdir(dir, { withFileTypes: true });
@@ -58,8 +84,8 @@ export async function getAllSubdirectories(dir) {
 	return subdirectories;
 }
 
-export function getImportedSASSFiles(filePath) {
-	const content = fs.readFileSync(filePath, 'utf8');
+export async function getImportedSASSFiles(filePath) {
+	const content = await fs.readFile(filePath, 'utf8');
 	const regex = /@(?:import|use)\s+['"]([^'"]+)['"]/g;
 	const imports = [];
 	let match;
@@ -75,9 +101,9 @@ export function getImportedSASSFiles(filePath) {
 	return imports;
 }
 
-export function getImportedJSFiles(filePath) {
+export async function getImportedJSFiles(filePath) {
 	try {
-		const content = fs.readFileSync(filePath, 'utf8');
+		const content = await fs.readFile(filePath, 'utf8');
 		const regex = /(?:import\s+[^'"]*\s+from\s+['"`]([^'">`]+)['"`]|import\s*\(\s*['"`]([^'">`]+)['"`]\s*\)|require\s*\(\s*['"`]([^'">`]+)['"`]\s*\))/g;
 		const imports = [];
 		let match;
@@ -95,43 +121,61 @@ export function getImportedJSFiles(filePath) {
 				if (!path.extname(resolvedPath)) {
 					for (const ext of extensions) {
 						const pathWithExt = resolvedPath + ext;
-						if (fs.existsSync(pathWithExt)) {
+						try {
+							await fs.access(pathWithExt);
 							imports.push(pathWithExt);
 							break;
+						} catch {
+							// File does not exist
 						}
 					}
 					const indexPath = path.join(resolvedPath, 'index');
 					for (const ext of extensions) {
 						const pathWithExt = indexPath + ext;
-						if (fs.existsSync(pathWithExt)) {
+						try {
+							await fs.access(pathWithExt);
 							imports.push(pathWithExt);
 							break;
+						} catch {
+							// File does not exist
 						}
 					}
 				} else {
-					if (fs.existsSync(resolvedPath)) {
+					try {
+						await fs.access(resolvedPath);
 						imports.push(resolvedPath);
+					} catch {
+						// File does not exist
 					}
 				}
 			}
 		}
-		return [...new Set(imports)].filter(importPath =>
-			importPath.startsWith(project.path) && fs.existsSync(importPath)
-		);
+		const unique = [...new Set(imports)];
+		const finalList = [];
+		for (const imp of unique) {
+			if (!imp.startsWith(project.path)) { continue; }
+			try {
+				await fs.access(imp);
+				finalList.push(imp);
+			} catch {
+				// File does not exist
+			}
+		}
+		return finalList;
 	} catch (error) {
 		return [];
 	}
 }
 
-export function getAllJSDependencies(filePath, visited = new Set()) {
+export async function getAllJSDependencies(filePath, visited = new Set()) {
 	if (visited.has(filePath)) {
 		return [];
 	}
 	visited.add(filePath);
-	const directDeps = getImportedJSFiles(filePath);
+	const directDeps = await getImportedJSFiles(filePath);
 	const allDeps = [...directDeps];
 	for (const dep of directDeps) {
-		const nestedDeps = getAllJSDependencies(dep, visited);
+		const nestedDeps = await getAllJSDependencies(dep, visited);
 		allDeps.push(...nestedDeps);
 	}
 	return [...new Set(allDeps)];
@@ -139,7 +183,7 @@ export function getAllJSDependencies(filePath, visited = new Set()) {
 
 export function addEntriesByFiletypes(filetypes = []) {
 	let finalFiles = [];
-	for (const [name, files] of Object.entries(project.package.sdc.entries)) {
+	for (const [name, files] of Object.entries(project.entries)) {
 		for (let file of files) {
 			let fullPath = project.path + file;
 			let extension = path.parse(fullPath).ext;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sdc-build-wp",
-	"version": "4.9.2",
+	"version": "5.0.1",
 	"description": "Custom WordPress build process.",
 	"engines": {
 		"node": ">=22"
@@ -34,7 +34,6 @@
 		"esbuild": "^0.25.8",
 		"eslint": "^9.31.0",
 		"fs-extra": "^11.3.0",
-		"minimist": "^1.2.8",
 		"postcss": "^8.5.6",
 		"postcss-scss": "^4.0.9",
 		"postcss-sort-media-queries": "^5.2.0",
@@ -42,6 +41,7 @@
 		"sharp": "^0.34.3",
 		"stylelint": "^16.22.0",
 		"svgo": "^4.0.0",
-		"tail": "^2.2.6"
+		"tail": "^2.2.6",
+		"yargs": "^18.0.0"
 	}
 }