addonova 1.0.0

package/template/tasks/bundle-css.js

@@ -0,0 +1,108 @@
+import path from 'node:path';
+import { build } from 'esbuild';
+import { sassPlugin } from 'esbuild-sass-plugin';
+import {getDestDir} from './paths.js';
+import {readFile, writeFile, getConfig, getAllFiles, log, fileExistsInConfig} from './utils.js';
+import {createTask} from './task.js';
+
+const srcSCSSDir = 'src/scss';
+
+async function removeTopSourceComment(filePath) {
+    const code = await readFile(filePath, 'utf8');
+    const newCode = code.replace(/^\/\*[\s\S]*?\*\//, '');
+    await writeFile(filePath, newCode);
+}
+
+async function esbuildCSS(config, isDebug, platform) {
+    let buildResult;
+    let outputs;
+    const dir = getDestDir({isDebug, platform});
+    
+    for (const [dest, src] of Object.entries(config.entry)) {
+        buildResult = await build({
+            entryPoints: src,
+            outdir: path.join(dir, dest),
+            entryNames: config.filename,
+            loader: {
+                '.scss': 'css'
+            },
+            plugins: [
+            sassPlugin({
+                    type: 'css',
+                    sourceMap: config.sourcemap,
+                })
+            ],
+            minify: config.minify,
+            sourcemap: config.sourcemap,
+            metafile: true,
+            write: true
+        });
+
+        if (!isDebug) {
+            outputs = Object.keys(buildResult.metafile.outputs);
+            for (const file of outputs) {
+                if (file.endsWith('.css')) {
+                    await removeTopSourceComment(file);
+                }
+            }
+        }
+    }
+}
+
+export function createBundleCSSTask(srcSCSSDir){
+    let currentWatchFiles;
+    const bundleCSS = async ({platforms, isDebug, logInfo, logWarn}) => {
+        for(const platform of platforms){
+            const config = (await getConfig(platform));
+            const scssConfig = config.scss;
+            if (scssConfig){
+                await esbuildCSS(scssConfig, isDebug, platform);
+                if (logInfo) log.ok(`Bundling CSS for ${platform}...`);
+            } else {
+                if(logWarn) log.warn(`No SCSS config found for ${platform}, skipping CSS bundling.`);
+            } 
+        }
+    }
+
+    const onChange = async (changedFiles, watcher, platforms, isDebug) => {
+        for(const platform of platforms){
+            const config = await getConfig(platform);
+            if (config.scss){
+                const exists = await fileExistsInConfig(
+                    config.scss.entry,
+                    changedFiles[0]
+                );
+                if (exists){
+                    const newConfig = {
+                        scss: {
+                            entry: exists,
+                            filename: config.scss.filename,
+                            minify: config.scss.minify,
+                            sourcemap: config.scss.sourcemap
+                        }
+                    }
+                    await esbuildCSS(newConfig.scss, isDebug, platform);
+                }
+                
+            }
+        }
+
+        const newWatchFiles = await getAllFiles(srcSCSSDir);
+        watcher.unwatch(
+            currentWatchFiles.filter((oldFile) => !newWatchFiles.includes(oldFile))
+        );
+        watcher.add(
+            newWatchFiles.filter((newFile) => currentWatchFiles.includes(newFile))
+        );
+    }
+    return createTask(
+        'bundle CSS',
+        bundleCSS,
+    ).addWatcher(
+        async () => {
+            currentWatchFiles = await getAllFiles(srcSCSSDir);
+            return currentWatchFiles;
+        }, onChange);
+}
+
+export default createBundleCSSTask(srcSCSSDir);

package/template/tasks/bundle-html.js

@@ -0,0 +1,91 @@
+import path from 'node:path';
+import { build } from 'esbuild';
+import { htmlPlugin } from '@craftamap/esbuild-plugin-html';
+import {getDestDir} from './paths.js';
+import {readFile, writeFile, getConfig, getAllFiles, log, fileExistsInConfig} from './utils.js';
+import {createTask} from './task.js';
+
+const srcHTMLDir = 'src/html';
+
+async function removeTopSourceComment(filePath) {
+    const code = await readFile(filePath, 'utf8');
+    const newCode = code.replace(/^\s*<!--[\s\S]*?-->\s*/, '');
+    await writeFile(filePath, newCode);
+}
+
+async function esbuildHTML(config, isDebug, platform){
+    let buildResult, outputs;
+    const dir = getDestDir({isDebug, platform});
+    for (const [dest, src] of Object.entries(config.entry)) {
+        buildResult = await build({
+            entryPoints: src,
+            outdir: path.join(dir, dest),
+            plugins: [htmlPlugin()],
+            loader: {
+                '.html': 'file'   // 🔥 Important
+            },
+            entryNames: config.filename,
+            assetNames: config.filename,
+            chunkNames: config.filename,
+            metafile: true,
+            write: true
+        });
+
+        if (!isDebug) {
+            outputs = Object.keys(buildResult.metafile.outputs);
+            for (const file of outputs) {
+                if (file.endsWith('.html')) {
+                    removeTopSourceComment(file);
+                }
+            }
+        }
+    }
+
+}
+
+export function createBundleHTMLTask(srcHTMLDir){
+    let currentWatchFiles;
+    const bundleHTML = async ({platforms, isDebug, logInfo, logWarn}) => {
+        for(const platform of platforms){
+            const config = (await getConfig(platform));
+            if(config.html){
+                await esbuildHTML(config.html, isDebug, platform);
+                if (logInfo) log.ok(`Bundling HTML for ${platform}...`);
+            } else{
+                if(logWarn) log.warn(`No HTML config found for ${platform}, skipping HTML bundling.`);
+            }
+        }
+    }
+
+    const onChange = async (changedFiles, watcher, platforms, isDebug) => {
+        for(const platform of platforms){
+            const config = (await getConfig(platform));
+            
+            if (!config.html) continue;
+            const exists = await fileExistsInConfig(
+                config.html.entry,
+                changedFiles[0]
+            );
+
+            if (exists){
+                const newConfig = {
+                    html: {
+                        entry: exists,
+                        filename: config.html.filename
+                    }
+                };
+                await esbuildHTML(newConfig.html, isDebug, platform);
+            }
+        }
+    }
+    return createTask(
+        'bundle HTML',
+        bundleHTML,
+    ).addWatcher(
+      async () => {
+        currentWatchFiles = await getAllFiles(srcHTMLDir);
+        return currentWatchFiles;
+    }, onChange);
+}
+
+export default createBundleHTMLTask(srcHTMLDir);

package/template/tasks/bundle-js.js

@@ -0,0 +1,95 @@
+import path from 'node:path';
+import { build } from 'esbuild';
+import {getDestDir} from './paths.js';
+import {readFile, writeFile, getConfig, getAllFiles, log, fileExistsInConfig} from './utils.js';
+import {createTask} from './task.js';
+
+const srcJSDir = 'src/js';
+
+async function removeTopSourceComment(filePath) {
+    const code = await readFile(filePath, 'utf8');
+    const newCode = code.replace(/^\/\/.*\n/, '');
+    await writeFile(filePath, newCode);
+}
+
+async function esbuildJS(config, isDebug, platform){
+    // console.log(`Starting JS build for ${config}...`);
+    let buildResult, outputs;
+    const dir = getDestDir({isDebug, platform});
+    for (const [dest, src] of Object.entries(config.entry)) {
+        buildResult = await build({
+            entryPoints: src,
+            bundle: false,
+            outdir: path.join(dir, dest),
+            entryNames: config.filename,
+            loader: {
+                '.js': 'js'
+            },
+            minify: !isDebug ? config.minify : false,
+            sourcemap: config.sourcemap,
+            drop: !isDebug ? ['console', 'debugger'] : [],
+            metafile: true,
+            write: true
+        });
+
+        if (!isDebug) {
+            outputs = Object.keys(buildResult.metafile.outputs);
+            for (const file of outputs) {
+                if (file.endsWith('.js')) {
+                    removeTopSourceComment(file);
+                }
+            }
+        }
+    }
+
+}
+
+export function createBundleJSTask(srcJSDir){
+    let currentWatchFiles;
+    const bundleJS = async ({platforms, isDebug, logInfo}) => {
+        for(const platform of platforms){
+            const config = /** @type {any} */ (await getConfig(platform));
+            if (config.js) {
+                if (logInfo) log.ok(`Bundling JS for ${platform}...`);
+                await esbuildJS(config.js, isDebug, platform);
+            } else {
+                if(logInfo) log.warn(`No JS config found for ${platform}, skipping JS bundling.`);
+            }
+        }
+    }
+
+    const onChange = async (changedFiles, watcher, platforms, isDebug) => {
+        for (const platform of platforms) {
+            const config = await getConfig(platform);
+
+            if (!config.js) continue;
+
+            const exists = await fileExistsInConfig(
+                config.js.entry,
+                changedFiles.join(', ')
+            );
+
+            if (exists) {
+                const newConfig = {
+                  js: {
+                    entry: exists,
+                    filename: config.js.filename,
+                    minify: config.js.minify,
+                    sourcemap: config.js.sourcemap
+                  }
+                };
+                await esbuildJS(newConfig.js, isDebug, platform);
+            }
+        }
+    };
+
+    return createTask(
+        'bundle JS',
+        bundleJS,
+    ).addWatcher(
+      async () => {
+        currentWatchFiles = await getAllFiles(srcJSDir);
+        return currentWatchFiles;
+    }, onChange);
+}
+export default createBundleJSTask(srcJSDir);

package/template/tasks/bundle-locales.js

@@ -0,0 +1,139 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import {getDestDir, absolutePath} from './paths.js';
+import {readFile, writeFile, getAllFiles, getConfig} from './utils.js';
+import {createTask} from './task.js';
+
+const srcLocalesDir = 'src/_locales';
+
+async function writeFiles(data, fileName, {platform, isDebug}){
+    const locale = fileName.substring(0, fileName.lastIndexOf('.')).replace('-', '_');
+    const getOutputPath = (dir) => `${dir}/_locales/${locale}/messages.json`;
+    const dir = getDestDir({isDebug, platform});
+    await writeFile(getOutputPath(dir), data);
+}
+
+async function localeFileToJson(filePath) {
+    const isfile = await readFile(filePath);
+    const file = isfile.replace(/^#.*?$/gm, '');
+
+    const messages = {};
+    const regex = /@([a-z0-9_]+)/ig;
+    let match;
+
+    while ((match = regex.exec(file))) {
+        const messageName = match[1];
+        const messageStart = match.index + match[0].length;
+        let messageEnd = file.indexOf('@', messageStart);
+
+        if (messageEnd < 0) {
+            messageEnd = file.length;
+        }
+
+        const messageContent = file
+            .substring(messageStart, messageEnd)
+            .replace(/\n/g, ' ')      // remove line breaks
+            .replace(/\s+/g, ' ')     // normalize extra spaces
+            .trim();
+
+        messages[messageName] = {
+            message: messageContent,
+        };
+    }
+
+    return messages;
+}
+
+async function mergeLocale(localesDir, code) {
+    let result = {};
+
+    const walk = async (dir) => {
+        const dirFiles = [];
+        const dirDirs = [];
+        const paths = await fs.readdir(dir);
+        for (const path of paths) {
+            const stat = await fs.stat(`${dir}/${path}`);
+            if (stat.isDirectory()) {
+                dirDirs.push(path);
+            } else {
+                dirFiles.push(path);
+            }
+        }
+        const localeFiles = dirFiles.filter((f) => f.split('.').at(-2) === code);
+        for (const localeFile of localeFiles) {
+            const messages = await localeFileToJson(`${dir}/${localeFile}`);
+            result = {...result, ...messages};
+        }
+        for (const folder of dirDirs) {
+            await walk(`${dir}/${folder}`);
+        }
+    };
+
+    await walk(localesDir);
+    return JSON.stringify(result, null, 4);
+}
+
+async function bundleLocales(srcLocalesDir, {platforms, isDebug, logInfo}) {
+    const absoluteSrcLocalesDir = absolutePath(srcLocalesDir);
+    const list = await fs.readdir(absoluteSrcLocalesDir);
+
+    for (const name of list) {
+        if (!name.endsWith('.i18n')) {
+            if (logInfo) log.ok(`Skipping non-locale file ${name} in ${srcLocalesDir}.`);
+            continue;
+        }
+        const code = (name.split('.').at(-2));
+        const locale = await mergeLocale(absoluteSrcLocalesDir, code);
+        const fileName = name.substring(name.lastIndexOf('/') + 1);
+        for (const platform of platforms) {
+            const config = (await getConfig(platform));
+            if (config && Object.keys(config).length != 0){
+                if(config.locales){
+                    if(config.locales.includes(code)){
+                        await writeFiles(locale, fileName, {platform, isDebug});
+                    }
+                } else{
+                    await writeFiles(locale, fileName, {platform, isDebug});
+                }
+            }
+        }
+        
+        if (logInfo) log.ok(`Bundled locale ${code} for platforms: ${platforms.join(', ')}.`);
+    }
+}
+
+export function createBundleLocalesTask(srcLocalesDir) {
+    const onChange = async (changedFiles, watcher, platforms, isDebug) => {
+        const localesSrcDir = absolutePath(srcLocalesDir);
+        for (const file of changedFiles) {
+            const fileName = file.substring(file.lastIndexOf(path.sep) + 1);
+            const code = (fileName.split('.').at(-2));
+            const locale = await mergeLocale(localesSrcDir, code);
+            for (const platform of platforms) {
+                const config = (await getConfig(platform));
+                if (config && Object.keys(config).length != 0){
+                    if(config.locales){
+                        if(config.locales.includes(code)){
+                            await writeFiles(locale, fileName, {platform, isDebug});
+                        }
+                    } else{
+                        await writeFiles(locale, fileName, {platform, isDebug});
+                    }
+                }
+            } 
+        }
+    }
+    return createTask(
+        'bundle locales',
+        (options) => bundleLocales(srcLocalesDir, options),
+    ).addWatcher(
+        async () => {
+            const currentWatchFiles = await getAllFiles(srcLocalesDir);
+            return currentWatchFiles;
+        },
+        onChange,
+    );
+} 
+
+export default createBundleLocalesTask(srcLocalesDir);

package/template/tasks/bundle-manifest.js

@@ -0,0 +1,54 @@
+import {getDestDir, absolutePath} from './paths.js';
+import {createTask} from './task.js';
+import {readJSON, writeJSON, getAllFiles, pathExists, getConfig} from './utils.js';
+
+const srcManifestDir = 'src/manifest';
+
+async function patchManifest(srcManifestDir, platform, isDebug, isWatch, isTest, version) {
+    const manifestPath = `${srcManifestDir}/manifest-${platform}.json`;
+    const existsManifest = await pathExists(manifestPath);
+    const patched = await readJSON(existsManifest ? manifestPath : absolutePath(`${srcManifestDir}/manifest.json`));
+    if (isDebug) {
+        patched.version = '1';
+        patched.description = `Debug build, platform: ${platform}, watch: ${isWatch ? 'yes' : 'no'}.`;
+    } else {
+        const packageJSON = await readJSON(absolutePath("package.json"));
+        patched.version = version || packageJSON.version;
+    }
+
+    if(platform == "naver"){
+        patched.default_locale = 'ko';
+    }
+    return patched;
+}
+
+
+async function bundleManifest(srcManifestDir, {platforms, isWatch, isDebug, isTest, logInfo, version}) {
+    for (const platform of platforms) {
+        const config = await getConfig(platform);
+        if (config && Object.keys(config).length != 0){
+            const manifest = await patchManifest(srcManifestDir, platform, isDebug, isWatch, isTest, version);
+            const destDir = getDestDir({isDebug, platform});
+            await writeJSON(`${destDir}/manifest.json`, manifest);
+            if (logInfo) log.ok(`Bundled manifest for platform ${platform}.`);
+        }
+    }
+
+}
+export function bundleManifestTask(srcManifestDir){
+    const onChange = async (changedFiles, watcher, platforms, isDebug) => {
+        await bundleManifest(srcManifestDir, {platforms, isWatch: true, isDebug, isTest: false, logInfo: false, version: null});
+    }
+    return createTask(
+        'bundle-manifest',
+        (options) => bundleManifest(srcManifestDir, options),
+    ).addWatcher(
+        async () => {
+            const currentWatchFiles = await getAllFiles(srcManifestDir);
+            return currentWatchFiles;
+        },
+        onChange,
+    );
+}
+
+export default bundleManifestTask(srcManifestDir);

package/template/tasks/cli.js

@@ -0,0 +1,85 @@
+import {join} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import process from 'node:process';
+import {fork} from 'node:child_process';
+import {log} from './utils.js';
+
+function printHelp() {
+    console.log([
+        'Volume booster build utility',
+        'Usage: npm run build -- [options]',
+        '',
+        'To narrow down the list of build targets (for efficiency):',
+        '  --all          Build for all platforms',
+        '  --chrome       Google Chrome (MV3)',
+        '  --edge         Microsoft Edge',
+        '  --firefox      Mozilla Firefox',
+        '  --opera        Opera Browser',
+        '  --naver        Naver Whale',
+        '  --thunderbird  Mozilla Thunderbird',
+        '',
+        'Other parameters:',
+        '  --release       Build release version (default)',
+        '  --debug         Build debug version',
+        '  --watch         Watch for changes and rebuild automatically',
+        '  --log-info      Log info messages',
+        '  --log-warn      Log warning messages',
+        '  --test          Build test version (for testing in development environment)',
+        '  --version=1.2.3 Append version to output file name (e.g. extension-name-chrome-1.2.3.zip)',
+        '  -h, --help      Show this help message',
+    ].join('\n'));
+}
+
+const __filename = join(fileURLToPath(import.meta.url), '../build.js');
+
+async function executeChildProcess(args) {
+    const child = fork(__filename, args);
+    process.on('SIGINT', () => {
+        child.kill('SIGKILL');
+        process.exit(130);
+    });
+    return new Promise((resolve, reject) => child.on('error', reject).on('close', resolve));
+}
+
+function validateArguments(args) {
+    const validationErrors = [];
+    const validFlags = [
+        '--all',
+        '--chrome',
+        '--edge',
+        '--naver',
+        '--opera',
+        '--firefox',
+        '--thunderbird',
+        '--release',
+        '--debug',
+        '--watch',
+        '--log-info',
+        '--log-warn',
+        '--test',
+        '--version=*',
+        '--help',
+        '-h'
+    ];
+    const invalidFlags = args.filter((flag) => !validFlags.includes(flag));
+    invalidFlags.forEach((flag) => validationErrors.push(`Invalid flag ${flag}`));
+    return validationErrors;
+}
+
+async function run() {
+    const args = process.argv.slice(3);
+    const shouldPrintHelp = args.length === 0 || process.argv[2] !== 'build' || args.includes('-h') || args.includes('--help');
+    if (shouldPrintHelp) {
+      printHelp();
+      process.exit(0);
+    }
+    const validationErrors = validateArguments(args);
+    if (validationErrors.length > 0) {
+        validationErrors.forEach(log.error);
+        log.error('❌ No target platform specified.');
+        printHelp();
+        process.exit(130);
+    }
+    await executeChildProcess(args);
+}
+run();

package/template/tasks/copy.js

@@ -0,0 +1,49 @@
+
+import {getDestDir} from './paths.js';
+import {copyFile, getAllFiles, getConfig, log} from './utils.js';
+import {createTask} from './task.js';
+import path from 'node:path';
+import { mkdir } from 'node:fs/promises';
+
+export function createCopyTask() {
+    const paths = [];
+    const assetsCopy = async ({platforms, isDebug, logInfo, logWarn}) => {
+        for(const platform of platforms){
+            const config = await getConfig(platform);
+            if (config.assets) {
+                for (const [dest, sources] of Object.entries(config.assets.entry)) {
+                    const srcList = Array.isArray(sources) ? sources : [sources];
+
+                    for (const src of srcList) {
+                        const files = await getAllFiles(src);
+
+                        for (const file of files) {
+                            const destDir = path.join(getDestDir({isDebug, platform}), dest);
+                            await mkdir(destDir, { recursive: true });
+
+                            const destFile = path.join(destDir, path.basename(file));
+                            await copyFile(file, destFile);
+                        }
+                    }
+                }
+                if (logInfo) log.ok(`Copying assets for ${platform}...`);
+            } else{
+                if(logWarn) log.warn(`No assets config found for ${platform}, skipping assets copy.`);
+            }
+        }
+
+    }
+    const onChange = async (changedFiles, watcher, platforms, isDebug) => {
+        await assetsCopy({platforms, isDebug, logInfo: false, logWarn: false})
+    }
+    return createTask(
+        'assets copy',
+        assetsCopy,
+    ).addWatcher(
+        paths,
+        onChange,
+    );
+}
+
+
+export default createCopyTask();

package/template/tasks/folder.js

@@ -0,0 +1,25 @@
+import process from 'node:process';
+import {createTask} from './task.js';
+import {getDestDir} from './paths.js';
+import {createFolder, removeFolder, log, getConfig} from './utils.js';
+
+export function createFolderTask() {
+    const folder = async ({platforms, isDebug, logInfo}) => {
+        process.env.NODE_ENV = isDebug ? 'development' : 'production';
+        for(const platform of platforms){
+            const config = await getConfig(platform);
+            if (config && Object.keys(config).length != 0){
+                await removeFolder(getDestDir({isDebug, platform}));
+                logInfo ? log.ok(`Folder Removed: ${getDestDir({isDebug, platform})}`) : null;
+
+                await createFolder(getDestDir({isDebug, platform}));
+                logInfo ? log.ok(`Folder Created: ${getDestDir({isDebug, platform})}`) : null;
+            }
+        }
+    };
+    return createTask(
+        'Environment Create',
+        folder,
+    );
+}
+export default createFolderTask();

package/template/tasks/paths.js

@@ -0,0 +1,21 @@
+import {createRequire} from 'node:module';
+import {dirname, join} from 'node:path';
+
+let rootDir = dirname(createRequire(import.meta.url).resolve('../../package.json'));
+
+export const absolutePath = (path) => {
+    return join(rootDir, path);
+};
+export function setRootDir(dir) {
+    rootDir = dir;
+}
+export function getDestDir({isDebug, platform}) {
+    const buildTypeDir = `build/${isDebug ? 'debug':'release'}`;
+    return `${buildTypeDir}/${platform}`;
+}
+export default {
+    getDestDir,
+    rootDir,
+    absolutePath,
+    setRootDir,
+};