@zulaica/site-bundler 0.6.4 → 0.8.0

package/lib/helpers/constants.mjs

@@ -1,81 +1,93 @@
+/* node:coverage disable */
 export const EMOJI = Object.freeze({
-  artistPalette: '\uD83C\uDFA8',
-  barChart: '\uD83D\uDCCA',
-  cardIndexDividers: '\uD83D\uDDC2',
-  constructionWorker: '\uD83D\uDC77',
-  fileCabinet: '\uD83D\uDDC4 ',
-  fileFolder: '\uD83D\uDCC1',
-  noEntry: '\u26D4\uFE0F',
-  package: '\uD83D\uDCE6',
-  wastebasket: '\ud83d\uddd1\ufe0f '
+  artistPalette: "\u{1f3a8}",
+  barChart: "\u{1f4ca}",
+  cardIndexDividers: "\u{1f5c2}",
+  constructionWorker: "\u{1f477}",
+  fileCabinet: "\u{1f5c4} ",
+  fileFolder: "\u{1f4c1}",
+  noEntry: "\u{26D4}",
+  package: "\u{1f4e6}",
+  wastebasket: "\u{1f5d1} ",
 });
 
 export const EXCLUSIONS = Object.freeze([
-  'index.html',
-  'script.hash.js',
-  'scripts',
-  'style.hash.css',
-  'styles'
+  "index.html",
+  "script.hash.js",
+  "scripts",
+  "style.hash.css",
+  "styles",
 ]);
 
 export const OPTIONS = Object.freeze({
   babel: {
     presets: [
       [
-        '@babel/preset-env',
+        "@babel/preset-env",
         {
-          targets: 'defaults',
-          modules: false
-        }
-      ]
+          targets: "defaults",
+          modules: false,
+        },
+      ],
     ],
     babelrc: false,
     comments: false,
     configFile: false,
-    minified: true
+    minified: true,
+  },
+  rollup: {
+    onwarn(warning, warn) {
+      if (warning.code === "EMPTY_BUNDLE") return;
+      warn(warning);
+    },
   },
   postcss: {
     cssnano: {
       preset: [
-        'advanced',
+        "advanced",
         {
           minifyFontValues: false,
           normalizeUrl: false,
           normalizeString: {
-            preferredQuote: 'single'
-          }
-        }
-      ]
+            preferredQuote: "single",
+          },
+        },
+      ],
     },
     url: [
       {
-        filter: '**/*.woff2',
-        url: 'rebase'
+        filter: "**/*.woff2",
+        url: "rebase",
       },
       {
-        filter: '**/*.woff',
-        url: 'rebase'
+        filter: "**/*.woff",
+        url: "rebase",
       },
       {
-        filter: '**/*.ttf',
-        url: 'rebase'
+        filter: "**/*.ttf",
+        url: "rebase",
       },
       {
-        filter: '**/*.webp',
-        url: (asset) => asset.relativePath
+        filter: "**/*.webp",
+        url: (asset) => asset.relativePath,
       },
       {
-        filter: '**/*.jpg',
-        url: (asset) => asset.relativePath
-      }
-    ]
+        filter: "**/*.jpg",
+        url: (asset) => asset.relativePath,
+      },
+    ],
   },
   posthtml: {
     htmlnano: {
-      collapseWhitespace: 'aggressive',
+      collapseBooleanAttributes: {
+        amphtml: false,
+      },
+      collapseWhitespace: "aggressive",
+      minifyCss: false,
       minifyJs: false,
-      removeComments: 'all',
-      removeEmptyAttributes: false
-    }
-  }
+      removeComments: "all",
+      removeEmptyAttributes: false,
+    },
+  },
 });
+/* node:coverage enable */

package/lib/helpers/logger.mjs

@@ -0,0 +1,22 @@
+import { exit, stderr, stdout } from "node:process";
+import { clearLine, cursorTo } from "node:readline";
+import { EMOJI } from "./constants.mjs";
+
+export default class Logger {
+  static error = (error) => {
+    stderr.write(`${EMOJI.noEntry} An error has occurred\n`);
+    stderr.write(`${error.toString()}\n\n`);
+    stderr.write("", () => exit(1));
+  };
+
+  static message = (message, update = false) => {
+    if (process.env.NODE_ENV !== "test") {
+      if (update) {
+        message += "\n";
+        cursorTo(stdout, 0);
+        clearLine(stdout, 0);
+      }
+      stdout.write(message);
+    }
+  };
+}

package/lib/helpers/tests.mjs

@@ -0,0 +1,112 @@
+import { mkdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach } from "node:test";
+
+const baseDir = join(tmpdir(), `site-bundler-test-${Date.now()}`);
+
+export const inputDir = join(baseDir, "input");
+export const outputDir = join(baseDir, "output");
+
+export const inputCSS = `
+/**
+ * This is a comment
+ */
+
+body {
+  margin: 0;
+  padding: 20px;
+  font-family: Arial, sans-serif;
+}
+
+h1 {
+  color: #333;
+}
+`;
+
+export const processedCSS =
+  "body{font-family:Arial,sans-serif;margin:0;padding:20px}h1{color:#333}";
+
+export const inputHTML = `
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <!-- This is a comment -->
+    <meta charset="utf-8" />
+    <style>
+      body {
+        margin: 0;
+        padding: 20px;
+      }
+    </style>
+    <link rel="stylesheet" href="style.hash.css" />
+    <script>
+      document.documentElement.classList.add("js");
+    </script>
+    <script src="script.hash.js"></script>
+  </head>
+  <body>
+    <header>
+      <h1>   Test   Site   </h1>
+      <nav>
+        <ul>
+          <li><a href="#home">Home</a></li>
+          <li><a href="#about">About</a></li>
+        </ul>
+      </nav>
+    </header>
+    <main>
+      <section>
+        <article>
+          <h2>Article                Title</h2>
+          <p>Article content goes here.</p>
+          <p aria-hidden="true">This is hidden.</p>
+        </article>
+      </section>
+      <aside>
+        <input type="text" disabled="disabled" placeholder="Enter text" />
+      </aside>
+    </main>
+    <footer>
+      <p>&copy; Year</p>
+    </footer>
+  </body>
+</html>
+`;
+
+export const processedHTML =
+  '<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><style>body{margin:0;padding:20px}</style><link rel="stylesheet" href="style.hash.css"><script>document.documentElement.classList.add("js");</script><script src="script.hash.js"></script></head><body><header><h1>Test Site</h1><nav><ul><li><a href="#home">Home</a></li><li><a href="#about">About</a></li></ul></nav></header><main><section><article><h2>Article Title</h2><p>Article content goes here.</p><p aria-hidden="true">This is hidden.</p></article></section><aside><input type="text" disabled placeholder="Enter text"></aside></main><footer><p>© Year</p></footer></body></html>';
+
+export const inputJS = `
+// This is a comment
+
+/**
+ * This is a comment
+ */
+
+const sum = (a, b) => {
+  return a + b;
+};
+
+console.log('Site loaded');
+
+document.addEventListener('DOMContentLoaded', () => {
+  console.log('DOM loaded');
+});
+
+export default sum;
+`;
+
+export const processedJS =
+  'const sum=(a,b)=>{return a+b};console.log("Site loaded");document.addEventListener("DOMContentLoaded",()=>{console.log("DOM loaded")});export{sum as default};';
+
+export const setUpTestHooks = () => {
+  beforeEach(async () => {
+    await mkdir(inputDir, { recursive: true });
+    await mkdir(outputDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(baseDir, { recursive: true, force: true });
+  });
+};

package/lib/index.mjs

@@ -1,38 +1,46 @@
 #!/usr/bin/env node
 
-import { program } from 'commander';
-import { readFile } from 'fs/promises';
-import { EMOJI, logError, logMessage } from './helpers/index.mjs';
+import { program } from "commander";
+import { access, readFile } from "node:fs/promises";
+import { EMOJI } from "./helpers/constants.mjs";
+import Logger from "./helpers/logger.mjs";
 import {
   copyAssets,
   preflight,
   processCSS,
   processHTML,
-  processJS
-} from './modules/index.mjs';
+  processJS,
+} from "./modules/index.mjs";
 
-(async () => {
-  const { version } = JSON.parse(
-    await readFile(new URL('../package.json', import.meta.url))
-  );
-  program
-    .version(version)
-    .requiredOption('-i, --input-dir <input>', 'The input directory')
-    .requiredOption('-o, --output-dir <output>', 'The output directory')
-    .parse();
-  const opts = program.opts();
+const { version } = JSON.parse(
+  await readFile(new URL("../package.json", import.meta.url)),
+);
+program
+  .version(version)
+  .requiredOption("-i, --input-dir <input>", "The input directory")
+  .requiredOption("-o, --output-dir <output>", "The output directory")
+  .parse();
+const opts = program.opts();
 
+async function validateInput() {
   try {
-    logMessage(`${EMOJI.constructionWorker} Site Bundler v${version}\n\n`);
-    await preflight(opts.outputDir);
-    await copyAssets(opts);
-    await processCSS(opts);
-    await processJS(opts);
-    await processHTML(opts);
-    logMessage(`${EMOJI.package} Finished!`);
-  } catch (error) {
-    logError(error);
-  } finally {
-    logMessage('\n\n');
+    await access(opts.inputDir);
+  } catch {
+    Logger.error(`Input directory does not exist: ${opts.inputDir}`);
   }
-})();
+}
+
+try {
+  Logger.message(`${EMOJI.constructionWorker} Site Bundler v${version}\n\n`);
+
+  await validateInput();
+  await preflight(opts.outputDir);
+  await copyAssets(opts);
+  await processCSS(opts);
+  await processJS(opts);
+  await processHTML(opts);
+
+  Logger.message(`${EMOJI.package} Finished!\n\n`);
+} catch (error) {
+  Logger.error(error);
+}

package/lib/index.test.mjs

@@ -0,0 +1,89 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { promisify } from "node:util";
+import { EMOJI } from "./helpers/constants.mjs";
+import {
+  inputCSS,
+  inputDir,
+  inputHTML,
+  inputJS,
+  outputDir,
+  setUpTestHooks,
+} from "./helpers/tests.mjs";
+
+const execFileAsync = promisify(execFile);
+const { version } = JSON.parse(
+  await readFile(new URL("../package.json", import.meta.url), "utf8"),
+);
+
+describe(`${EMOJI.package} CLI Integration`, () => {
+  setUpTestHooks();
+
+  it("should display version", async () => {
+    const { stdout } = await execFileAsync("node", [
+      join(process.cwd(), "lib", "index.mjs"),
+      "--version",
+    ]);
+
+    assert.ok(stdout.includes(version));
+  });
+
+  it("should process complete site", async () => {
+    await writeFile(join(inputDir, "index.html"), inputHTML);
+    await writeFile(join(inputDir, "style.hash.css"), inputCSS);
+    await writeFile(join(inputDir, "script.hash.js"), inputJS);
+    await writeFile(join(inputDir, "favicon.ico"), "");
+
+    await assert.doesNotReject(() =>
+      execFileAsync("node", [
+        join(process.cwd(), "lib", "index.mjs"),
+        "-i",
+        inputDir,
+        "-o",
+        outputDir,
+      ]),
+    );
+
+    const outputFiles = await readdir(outputDir);
+
+    assert.deepEqual(outputFiles.sort(), [
+      "favicon.ico",
+      "index.html",
+      "script.hash.js",
+      "style.hash.css",
+    ]);
+  });
+
+  it("should handle non-existent input directory", async () => {
+    const nonExistentDir = join(inputDir, "non-existent");
+
+    await assert.rejects(
+      () =>
+        execFileAsync("node", [
+          join(process.cwd(), "lib", "index.mjs"),
+          "-i",
+          nonExistentDir,
+          "-o",
+          outputDir,
+        ]),
+      /Input directory does not exist/,
+    );
+  });
+
+  it("should handle empty input directory", async () => {
+    await assert.rejects(
+      () =>
+        execFileAsync("node", [
+          join(process.cwd(), "lib", "index.mjs"),
+          "-i",
+          inputDir,
+          "-o",
+          outputDir,
+        ]),
+      /An error has occurred/,
+    );
+  });
+});

package/lib/modules/copyAssets.mjs

@@ -1,29 +1,32 @@
-import { cp, readdir } from 'fs/promises';
-import { EMOJI, EXCLUSIONS, logMessage } from '../helpers/index.mjs';
+import { cp, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { EMOJI, EXCLUSIONS } from "../helpers/constants.mjs";
+import Logger from "../helpers/logger.mjs";
 
 const copyAssets = async ({ inputDir, outputDir }) => {
   const assets = await readdir(inputDir);
-  for (const exclusion in EXCLUSIONS) {
-    assets.splice(assets.indexOf(exclusion), 1);
+  const filteredAssets = assets.filter((asset) => !EXCLUSIONS.includes(asset));
+
+  if (!filteredAssets.length) {
+    return;
   }
 
-  if (assets.length) {
-    logMessage(
-      `${EMOJI.cardIndexDividers}  Copying assets (0/${assets.length})`
-    );
-    for (const [index, asset] of assets.entries()) {
-      logMessage(
-        `${EMOJI.cardIndexDividers}  Copying assets (${index + 1}/${
-          assets.length
-        })`,
-        true
-      );
-      await cp(`${inputDir}/${asset}`, `${outputDir}/${asset}`, {
-        recursive: true
+  Logger.message(
+    `${EMOJI.cardIndexDividers}  Copying ${filteredAssets.length} assets…`,
+  );
+
+  await Promise.all(
+    filteredAssets.map(async (asset) => {
+      await cp(join(inputDir, asset), join(outputDir, asset), {
+        recursive: true,
       });
-    }
-    logMessage('\n');
-  }
+    }),
+  );
+
+  Logger.message(
+    `${EMOJI.cardIndexDividers}  Copied ${filteredAssets.length} assets`,
+    true,
+  );
 };
 
 export default copyAssets;

package/lib/modules/copyAssets.test.mjs

@@ -0,0 +1,86 @@
+import assert from "node:assert/strict";
+import { mkdir, readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { EMOJI } from "../helpers/constants.mjs";
+import {
+  inputCSS,
+  inputDir,
+  inputHTML,
+  inputJS,
+  outputDir,
+  setUpTestHooks,
+} from "../helpers/tests.mjs";
+import copyAssets from "./copyAssets.mjs";
+
+describe(`${EMOJI.cardIndexDividers}  copyAssets()`, () => {
+  setUpTestHooks();
+
+  it("should copy all non-excluded assets", async () => {
+    await writeFile(join(inputDir, "image.png"), "");
+    await writeFile(join(inputDir, "document.pdf"), "");
+    await writeFile(join(inputDir, "script.js"), inputJS);
+
+    await assert.doesNotReject(() => copyAssets({ inputDir, outputDir }));
+
+    const copiedFiles = await readdir(outputDir);
+
+    assert.deepEqual(copiedFiles.sort(), [
+      "document.pdf",
+      "image.png",
+      "script.js",
+    ]);
+  });
+
+  it("should exclude files listed in EXCLUSIONS", async () => {
+    await mkdir(join(inputDir, "scripts"), { recursive: true });
+    await mkdir(join(inputDir, "styles"), { recursive: true });
+    await writeFile(join(inputDir, "image.png"), "");
+    await writeFile(join(inputDir, "index.html"), inputHTML);
+    await writeFile(join(inputDir, "script.hash.js"), inputJS);
+    await writeFile(join(inputDir, "style.hash.css"), inputCSS);
+    await writeFile(join(inputDir, "scripts", "app.js"), inputJS);
+    await writeFile(join(inputDir, "styles", "main.css"), inputCSS);
+
+    await assert.doesNotReject(() => copyAssets({ inputDir, outputDir }));
+
+    const copiedFiles = await readdir(outputDir);
+
+    assert.deepStrictEqual(copiedFiles, ["image.png"]);
+  });
+
+  it("should handle empty input directory", async () => {
+    await assert.doesNotReject(() => copyAssets({ inputDir, outputDir }));
+
+    const copiedFiles = await readdir(outputDir);
+
+    assert.deepStrictEqual(copiedFiles, []);
+  });
+
+  it("should copy directories recursively", async () => {
+    await mkdir(join(inputDir, "assets"), { recursive: true });
+    await mkdir(join(inputDir, "assets", "images"), { recursive: true });
+    await writeFile(join(inputDir, "assets", "file.txt"), "");
+    await writeFile(join(inputDir, "assets", "images", "logo.png"), "");
+
+    await assert.doesNotReject(() => copyAssets({ inputDir, outputDir }));
+
+    const copiedFiles = await readdir(outputDir, { withFileTypes: true });
+    const assetsDir = copiedFiles.find((f) => f.name === "assets");
+    const subFiles = await readdir(join(outputDir, "assets"));
+
+    assert.ok(assetsDir.isDirectory());
+    assert.deepStrictEqual(subFiles.sort(), ["file.txt", "images"]);
+  });
+
+  it("should handle only excluded files", async () => {
+    await writeFile(join(inputDir, "index.html"), inputHTML);
+    await writeFile(join(inputDir, "script.hash.js"), inputCSS);
+
+    await assert.doesNotReject(() => copyAssets({ inputDir, outputDir }));
+
+    const copiedFiles = await readdir(outputDir);
+
+    assert.deepStrictEqual(copiedFiles, []);
+  });
+});

package/lib/modules/index.mjs

@@ -1,7 +1,7 @@
-import copyAssets from './copyAssets.mjs';
-import preflight from './preflight.mjs';
-import processCSS from './processCSS.mjs';
-import processHTML from './processHTML.mjs';
-import processJS from './processJS.mjs';
+import copyAssets from "./copyAssets.mjs";
+import preflight from "./preflight.mjs";
+import processCSS from "./processCSS.mjs";
+import processHTML from "./processHTML.mjs";
+import processJS from "./processJS.mjs";
 
 export { copyAssets, preflight, processCSS, processHTML, processJS };

package/lib/modules/preflight.mjs

@@ -1,31 +1,34 @@
-import { mkdir, readdir, rm } from 'fs/promises';
-import { EMOJI, logError, logMessage } from '../helpers/index.mjs';
+import { mkdir, readdir, rm } from "node:fs/promises";
+import { EMOJI } from "../helpers/constants.mjs";
+import Logger from "../helpers/logger.mjs";
 
 const preflight = async (outputDir) => {
   try {
     const files = await readdir(outputDir);
 
     if (files.length) {
-      logMessage(
-        `${EMOJI.wastebasket} Removing old ${outputDir} files (0/${files.length})`
+      Logger.message(`${EMOJI.wastebasket} Removing old ${outputDir} files…`);
+
+      await rm(outputDir, { recursive: true, force: true });
+      await mkdir(outputDir);
+
+      Logger.message(
+        `${EMOJI.wastebasket} Removed old ${outputDir} files`,
+        true,
       );
-      for (const [index, file] of files.entries()) {
-        logMessage(
-          `${EMOJI.wastebasket} Removing old ${outputDir} files (${index + 1}/${
-            files.length
-          })`,
-          true
-        );
-        await rm(`${outputDir}/${file}`, { recursive: true, force: true });
-      }
-      logMessage('\n');
     }
   } catch (error) {
-    if (error.code === 'ENOENT') {
-      logMessage(`${EMOJI.fileFolder} Creating ${outputDir} directory\n`);
+    if (error.code === "ENOENT") {
+      Logger.message(`${EMOJI.fileFolder} Creating ${outputDir} directory…`);
+
       await mkdir(outputDir);
+
+      Logger.message(
+        `${EMOJI.fileFolder} Created ${outputDir} directory`,
+        true,
+      );
     } else {
-      logError(`${error} \n`);
+      Logger.error(error);
     }
   }
 };

package/lib/modules/preflight.test.mjs

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { mkdir, readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { EMOJI } from "../helpers/constants.mjs";
+import { outputDir, setUpTestHooks } from "../helpers/tests.mjs";
+import preflight from "./preflight.mjs";
+
+describe(`${EMOJI.fileFolder} preflight()`, () => {
+  setUpTestHooks();
+
+  it("should create output directory if it does not exist", async () => {
+    const nonExistentDir = join(outputDir, "non-existent");
+    await assert.doesNotReject(() => preflight(nonExistentDir));
+
+    const files = await readdir(nonExistentDir);
+
+    assert.ok(files !== undefined);
+    assert.deepEqual(files, []);
+  });
+
+  it("should remove all files and recreate output directory", async () => {
+    await mkdir(join(outputDir, "subdir"), { recursive: true });
+    await writeFile(join(outputDir, "file1.txt"), "");
+    await writeFile(join(outputDir, "file2.txt"), "");
+    await writeFile(join(outputDir, "subdir", "file3.txt"), "");
+
+    const initialFiles = await readdir(outputDir, { withFileTypes: true });
+
+    assert.ok(initialFiles.length > 0);
+    await assert.doesNotReject(() => preflight(outputDir));
+
+    const finalFiles = await readdir(outputDir);
+
+    assert.deepEqual(finalFiles, []);
+  });
+});

package/lib/modules/processCSS.mjs

@@ -1,30 +1,43 @@
-import cssnanoPlugin from 'cssnano';
-import { readFile, writeFile } from 'fs/promises';
-import postcss from 'postcss';
-import atImport from 'postcss-import';
-import postcssPresetEnv from 'postcss-preset-env';
-import url from 'postcss-url';
-import { EMOJI, OPTIONS, logMessage } from '../helpers/index.mjs';
+import cssnanoPlugin from "cssnano";
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import postcss from "postcss";
+import atImport from "postcss-import";
+import postcssPresetEnv from "postcss-preset-env";
+import url from "postcss-url";
+import { EMOJI, OPTIONS } from "../helpers/constants.mjs";
+import Logger from "../helpers/logger.mjs";
+
+const { cssnano, url: cssUrl } = OPTIONS.postcss;
+
+const postcssProcessor = postcss()
+  .use(atImport())
+  .use(postcssPresetEnv())
+  .use(url(cssUrl))
+  .use(cssnanoPlugin(cssnano));
 
 const processCSS = async ({ inputDir, outputDir }) => {
-  logMessage(`${EMOJI.artistPalette} Processing styles`);
-  const file = 'style.hash.css';
-  const input = `${inputDir}/${file}`;
-  const output = `${outputDir}/${file}`;
+  const assets = await readdir(inputDir);
+  const file = "style.hash.css";
+
+  if (!assets.includes(file)) {
+    return;
+  }
+
+  Logger.message(`${EMOJI.artistPalette} Processing styles…`);
+
+  const input = join(inputDir, file);
+  const output = join(outputDir, file);
+  const data = await readFile(input, { encoding: "utf8" });
+  const code = await processCSSData(input, data);
 
-  const data = await readFile(input, { encoding: 'utf8' });
-  const code = await _processData(input, data);
   await writeFile(output, code);
-  logMessage('\n');
+
+  Logger.message(`${EMOJI.artistPalette} Processed styles`, true);
 };
 
-async function _processData(input, data) {
-  const { css } = await postcss()
-    .use(atImport())
-    .use(postcssPresetEnv())
-    .use(url(OPTIONS.postcss.url))
-    .use(cssnanoPlugin(OPTIONS.postcss.cssnano))
-    .process(data, { from: input });
+export async function processCSSData(input, data) {
+  const { css } = await postcssProcessor.process(data, { from: input });
 
   return css;
 }

package/lib/modules/processCSS.test.mjs

@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { EMOJI } from "../helpers/constants.mjs";
+import {
+  inputCSS,
+  inputDir,
+  outputDir,
+  processedCSS,
+  setUpTestHooks,
+} from "../helpers/tests.mjs";
+import processCSS from "./processCSS.mjs";
+
+describe(`${EMOJI.artistPalette} processCSS()`, () => {
+  setUpTestHooks();
+
+  it("should process CSS file and write output", async (sub) => {
+    await writeFile(join(inputDir, "style.hash.css"), inputCSS);
+
+    await assert.doesNotReject(() => processCSS({ inputDir, outputDir }));
+
+    const output = await readFile(join(outputDir, "style.hash.css"), "utf8");
+
+    sub.test("minimized as a single line", () => {
+      assert.equal(output, processedCSS);
+    });
+    sub.test("with whitespace trimmed", () => {
+      assert.ok(output.trim().length < inputCSS.trim().length);
+    });
+    sub.test("with comments removed", () => {
+      assert.doesNotMatch(output, /\/\*\*/);
+    });
+  });
+
+  it("should handle CSS imports", async () => {
+    await writeFile(join(inputDir, "style.hash.css"), '@import "base.css";');
+    await writeFile(join(inputDir, "base.css"), inputCSS);
+
+    await assert.doesNotReject(() => processCSS({ inputDir, outputDir }));
+
+    const output = await readFile(join(outputDir, "style.hash.css"), "utf8");
+
+    assert.ok(output.includes(processedCSS));
+  });
+
+  it("should handle empty CSS file", async () => {
+    await writeFile(join(inputDir, "style.hash.css"), "");
+
+    await assert.doesNotReject(() => processCSS({ inputDir, outputDir }));
+
+    const output = await readFile(join(outputDir, "style.hash.css"), "utf8");
+
+    assert.equal(output, "");
+  });
+
+  it("should skip processing if CSS file does not exist", async () => {
+    await assert.doesNotReject(() => processCSS({ inputDir, outputDir }));
+  });
+});

package/lib/modules/processHTML.mjs

@@ -1,28 +1,91 @@
-import { readFile, writeFile } from 'fs/promises';
-import htmlnano from 'htmlnano';
-import posthtml from 'posthtml';
-import { hash } from 'posthtml-hash';
-import { EMOJI, OPTIONS, logMessage } from '../helpers/index.mjs';
+import htmlnano from "htmlnano";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import posthtml from "posthtml";
+import { hash } from "posthtml-hash";
+import { EMOJI, OPTIONS } from "../helpers/constants.mjs";
+import Logger from "../helpers/logger.mjs";
+import { processCSSData } from "./processCSS.mjs";
+import { processJSData } from "./processJS.mjs";
+
+const { htmlnano: htmlnanoOptions } = OPTIONS.posthtml;
 
 const processHTML = async ({ inputDir, outputDir }) => {
-  logMessage(`${EMOJI.fileCabinet} Processing HTML`);
-  const file = 'index.html';
-  const input = `${inputDir}/${file}`;
-  const output = `${outputDir}/${file}`;
+  Logger.message(`${EMOJI.fileCabinet} Processing HTML…`);
+  const file = "index.html";
+  const input = join(inputDir, file);
+  const output = join(outputDir, file);
+
+  const data = await readFile(input, { encoding: "utf8" });
+  const code = await processHTMLData(outputDir, data);
 
-  const data = await readFile(input, { encoding: 'utf8' });
-  const code = await _processData(outputDir, data);
   await writeFile(output, code);
-  logMessage('\n');
+
+  Logger.message(`${EMOJI.fileCabinet} Processed HTML`, true);
 };
 
-async function _processData(outputDir, data) {
-  const { html } = await posthtml()
-    .use(htmlnano(OPTIONS.posthtml.htmlnano, htmlnano.presets.safe))
-    .use(hash({ path: outputDir, pattern: new RegExp(/hash/) }))
-    .process(data);
+async function processHTMLData(path, data) {
+  let posthtmlInstance = posthtml()
+    .use(processInlineStyles())
+    .use(processInlineScripts())
+    .use(htmlnano(htmlnanoOptions, htmlnano.presets.safe));
+
+  /* node:coverage disable */
+  // Do not perform hash replacement when running tests
+  if (process.env.NODE_ENV !== "test") {
+    posthtmlInstance = posthtmlInstance.use(
+      hash({ path, pattern: new RegExp(/hash/) }),
+    );
+  }
+  /* node:coverage enable */
+
+  const { html } = await posthtmlInstance.process(data);
 
   return html;
 }
 
+/* node:coverage disable */
+function processInlineContent(tagName, shouldProcess, processFn) {
+  return function () {
+    return async function (tree) {
+      const itemsToProcess = [];
+
+      tree.walk((node) => {
+        if (node.tag === tagName && shouldProcess(node)) {
+          const content = Array.isArray(node.content)
+            ? node.content.join("")
+            : node.content;
+
+          itemsToProcess.push({ node, content });
+        }
+
+        return node;
+      });
+
+      await Promise.all(
+        itemsToProcess.map(async ({ node, content }) => {
+          node.content = await processFn(content);
+        }),
+      );
+    };
+  };
+}
+/* node:coverage enable */
+
+/* node:coverage disable */
+const processInlineScripts = processInlineContent(
+  "script",
+  (node) => node.content && !node.attrs?.src,
+  processJSData,
+);
+/* node:coverage enable */
+
+/* node:coverage disable */
+const processInlineStyles = processInlineContent(
+  "style",
+  (node) => node.content,
+  (content) => processCSSData(null, content),
+);
+/* node:coverage enable */
+
 export default processHTML;

package/lib/modules/processHTML.test.mjs

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { EMOJI } from "../helpers/constants.mjs";
+import {
+  inputDir,
+  inputHTML,
+  outputDir,
+  processedHTML,
+  setUpTestHooks,
+} from "../helpers/tests.mjs";
+import processHTML from "./processHTML.mjs";
+
+describe(`${EMOJI.fileCabinet} processHTML()`, () => {
+  setUpTestHooks();
+
+  it("should process HTML file and write output", async (sub) => {
+    await writeFile(join(inputDir, "index.html"), inputHTML);
+
+    await assert.doesNotReject(() => processHTML({ inputDir, outputDir }));
+
+    const output = await readFile(join(outputDir, "index.html"), "utf8");
+
+    sub.test("minimized as a single line", () => {
+      assert.equal(output, processedHTML);
+    });
+    sub.test("with whitespace trimmed", () => {
+      assert.ok(output.trim().length < inputHTML.trim().length);
+      assert.ok(output.includes("Test Site"));
+      assert.ok(output.includes("Article Title"));
+    });
+    sub.test("with comments removed", () => {
+      assert.doesNotMatch(output, /<!--/);
+    });
+    sub.test("with boolean attributes handled correctly", () => {
+      assert.ok(output.includes("disabled"));
+      assert.doesNotMatch(output, /disabled="disabled"/);
+    });
+  });
+
+  it("should handle empty HTML file", async () => {
+    await writeFile(join(inputDir, "index.html"), "");
+    await processHTML({ inputDir, outputDir });
+
+    const output = await readFile(join(outputDir, "index.html"), "utf8");
+
+    assert.equal(output, "");
+  });
+});

package/lib/modules/processJS.mjs

@@ -1,31 +1,48 @@
-import { transformFromAstAsync } from '@babel/core';
-import { parse } from '@babel/parser';
-import { readFile, writeFile } from 'fs/promises';
-import { rollup } from 'rollup';
-import { EMOJI, OPTIONS, logMessage } from '../helpers/index.mjs';
+import { transformFromAstAsync } from "@babel/core";
+import { parse } from "@babel/parser";
+import { readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { rollup } from "rollup";
+import { EMOJI, OPTIONS } from "../helpers/constants.mjs";
+import Logger from "../helpers/logger.mjs";
+
+const { babel: babelOptions, rollup: rollupOptions } = OPTIONS;
 
 const processJS = async ({ inputDir, outputDir }) => {
-  logMessage(`${EMOJI.barChart} Processing scripts`);
-  const file = 'script.hash.js';
-  const input = `${inputDir}/${file}`;
-  const output = `${outputDir}/${file}`;
-
-  await _bundleJS(input, output);
-  const data = await readFile(output, { encoding: 'utf8' });
-  const code = await _processData(data);
+  const assets = await readdir(inputDir);
+  const file = "script.hash.js";
+
+  if (!assets.includes(file)) {
+    return;
+  }
+
+  Logger.message(`${EMOJI.barChart} Processing scripts…`);
+
+  const input = join(inputDir, file);
+  const output = join(outputDir, file);
+  const bundledCode = await bundleJS(input);
+  const code = await processJSData(bundledCode);
+
   await writeFile(output, code);
-  logMessage('\n');
+
+  Logger.message(`${EMOJI.barChart} Processed scripts`, true);
 };
 
-async function _bundleJS(input, output) {
-  const bundle = await rollup({ input });
-  await bundle.write({ file: output });
+async function bundleJS(input) {
+  const bundle = await rollup({
+    input,
+    ...rollupOptions,
+  });
+  const { output } = await bundle.generate({ format: "es" });
+
   await bundle.close();
+
+  return output[0].code;
 }
 
-async function _processData(data) {
-  const ast = parse(data, { sourceType: 'module' });
-  const { code } = await transformFromAstAsync(ast, data, OPTIONS.babel);
+export async function processJSData(data) {
+  const ast = parse(data, { sourceType: "module" });
+  const { code } = await transformFromAstAsync(ast, data, babelOptions);
 
   return code;
 }

package/lib/modules/processJS.test.mjs

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { EMOJI } from "../helpers/constants.mjs";
+import {
+  inputDir,
+  inputJS,
+  outputDir,
+  processedJS,
+  setUpTestHooks,
+} from "../helpers/tests.mjs";
+import processJS from "./processJS.mjs";
+
+describe(`${EMOJI.barChart} processJS()`, () => {
+  setUpTestHooks();
+
+  it("should process JavaScript file and write output", async (sub) => {
+    await writeFile(join(inputDir, "script.hash.js"), inputJS);
+
+    await assert.doesNotReject(() => processJS({ inputDir, outputDir }));
+
+    const output = await readFile(join(outputDir, "script.hash.js"), "utf8");
+
+    sub.test("minimized as a single line", () => {
+      assert.equal(output, processedJS);
+    });
+    sub.test("with whitespace trimmed", () => {
+      assert.ok(output.trim().length < inputJS.trim().length);
+    });
+    sub.test("with comments removed", () => {
+      assert.doesNotMatch(output, /\/\/ This is a comment/);
+      assert.doesNotMatch(output, /\/\*\*/);
+    });
+  });
+
+  it("should bundle ES modules", async () => {
+    await writeFile(
+      join(inputDir, "script.hash.js"),
+      `
+      import sum from './input.js';
+      console.log(sum(2, 3));
+    `,
+    );
+    await writeFile(join(inputDir, "input.js"), inputJS);
+
+    await assert.doesNotReject(() => processJS({ inputDir, outputDir }));
+
+    const output = await readFile(join(outputDir, "script.hash.js"), "utf8");
+
+    assert.ok(output.includes("const sum=(a,b)=>{return a+b}"));
+  });
+
+  it("should handle empty JavaScript file", async () => {
+    await writeFile(join(inputDir, "script.hash.js"), "");
+
+    await assert.doesNotReject(() => processJS({ inputDir, outputDir }));
+
+    const output = await readFile(join(outputDir, "script.hash.js"), "utf8");
+
+    assert.equal(output, "");
+  });
+
+  it("should skip processing if JavaScript file does not exist", async () => {
+    await assert.doesNotReject(() => processJS({ inputDir, outputDir }));
+  });
+});

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@zulaica/site-bundler",
   "author": "David Zulaica",
-  "version": "0.6.4",
+  "version": "0.8.0",
   "type": "module",
   "engines": {
-    "node": ">=24.12.0"
+    "node": ">=24.18.0"
   },
   "license": "UNLICENSED",
   "bin": {
@@ -20,7 +20,9 @@
   ],
   "scripts": {
     "lint": "eslint \"lib/**\"",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "NODE_ENV=test node --test --test-concurrency=1 --require \"./lib/helpers/tests.mjs\"",
+    "test:watch": "npm run test -- --watch",
+    "test:coverage": "npm run test -- --experimental-test-coverage --test-coverage-exclude=\"**/helpers/**\" --test-coverage-exclude=\"**/*.test.mjs\""
   },
   "repository": {
     "type": "git",
@@ -31,29 +33,33 @@
   },
   "homepage": "https://github.com/zulaica/site-bundler#readme",
   "dependencies": {
-    "@babel/core": "7.28.5",
-    "@babel/parser": "7.28.5",
-    "@babel/preset-env": "7.28.5",
-    "commander": "14.0.2",
-    "cssnano": "7.1.2",
-    "cssnano-preset-advanced": "7.0.10",
-    "htmlnano": "3.0.0",
-    "postcss": "8.5.6",
+    "@babel/core": "8.0.1",
+    "@babel/parser": "8.0.4",
+    "@babel/preset-env": "8.0.2",
+    "commander": "15.0.0",
+    "cssnano": "8.0.2",
+    "cssnano-preset-advanced": "8.0.2",
+    "htmlnano": "3.4.0",
+    "postcss": "8.5.20",
     "postcss-import": "16.1.1",
-    "postcss-preset-env": "10.5.0",
-    "postcss-url": "10.1.3",
+    "postcss-preset-env": "11.3.2",
+    "postcss-url": "10.1.4",
     "posthtml": "0.16.7",
     "posthtml-hash": "1.2.2",
-    "rollup": "4.54.0"
+    "rollup": "4.62.2"
   },
   "devDependencies": {
-    "eslint": "9.39.2",
+    "@eslint/js": "10.0.1",
+    "eslint": "10.7.0",
     "eslint-config-prettier": "10.1.8",
-    "eslint-plugin-prettier": "5.5.4",
-    "globals": "16.5.0",
-    "prettier": "3.7.4"
+    "eslint-plugin-prettier": "5.5.6",
+    "globals": "17.7.0",
+    "prettier": "3.9.5"
   },
   "volta": {
-    "node": "24.12.0"
+    "node": "24.18.0"
+  },
+  "allowScripts": {
+    "fsevents@2.3.3": true
   }
 }

package/lib/helpers/index.mjs

@@ -1,4 +0,0 @@
-import { EMOJI, EXCLUSIONS, OPTIONS } from './constants.mjs';
-import { logError, logMessage } from './loggers.mjs';
-
-export { EMOJI, EXCLUSIONS, logError, logMessage, OPTIONS };

package/lib/helpers/loggers.mjs

@@ -1,16 +0,0 @@
-import { exit, stderr, stdout } from 'process';
-import { cursorTo } from 'readline';
-import { EMOJI } from './index.mjs';
-
-export const logError = (error) => {
-  stderr.write(`\n${EMOJI.noEntry} An error has occurred\n`);
-  stderr.write(error.toString());
-  exit(1);
-};
-
-export const logMessage = (message, update = false) => {
-  if (update) {
-    cursorTo(stdout, 0, null);
-  }
-  stdout.write(message);
-};