@changke/staticnext-build 0.13.0 → 0.27.0

package/AGENTS.md

@@ -0,0 +1,195 @@
+# AGENTS.md
+
+Guidelines for AI agents working in the `@changke/staticnext-build` repository.
+
+## Project Overview
+
+Node.js CLI build tool (`sn-build`) that orchestrates static asset builds: cleaning,
+copying, Markdown-to-HTML, HTML prototyping (Nunjucks or jstmpl), JS/TS bundling,
+and CSS bundling via esbuild. Pure JavaScript, ESM-only, no TypeScript compiler,
+no React/Next.js framework.
+
+## Build / Lint / Test Commands
+
+```bash
+# Lint (ESLint v9 flat config with @stylistic)
+npm run lint
+
+# Run all tests (Node.js built-in test runner, requires Node >= 22.14.0)
+npm test
+
+# Run a single test file
+node --test test/util.test.mjs
+
+# Run tests matching a name pattern
+node --test --test-name-pattern="getTargetPathString" test/util.test.mjs
+
+# Lint + test (runs automatically before npm publish)
+npm run prepublishOnly
+```
+
+There is no build/compile step -- the source is plain `.mjs` files executed directly.
+
+## Module System
+
+- **ESM only.** Package has `"type": "module"`. All files use `.mjs` extension.
+- No CommonJS (`require`, `module.exports`) anywhere.
+
+## Code Style
+
+Formatting is enforced entirely by ESLint with `@stylistic/eslint-plugin` -- there
+is no Prettier. Run `npm run lint` to check.
+
+### Formatting Rules
+
+| Rule | Setting |
+|------|---------|
+| Indentation | 2 spaces |
+| Quotes | Single quotes |
+| Semicolons | Always required |
+| Trailing commas | Never (`comma-dangle: never`) |
+| Object braces | No spaces (`{foo}` not `{ foo }`) |
+| Block spacing | No spaces (`{return x}` not `{ return x }`) |
+| Brace style | 1TBS (opening brace on same line) |
+| Arrow parens | As-needed (omit for single param) |
+| Named function parens | No space before: `function foo()` |
+| Async arrow | Space required: `async () =>` |
+| Line endings | LF only |
+| Trailing whitespace | Trimmed (except in `.md` files) |
+| Final newline | Always insert |
+
+### Import Conventions
+
+```js
+// Node built-ins: always use `node:` prefix
+import {readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {env} from 'node:process';
+
+// Third-party: bare specifiers
+import {build} from 'esbuild';
+import {marked} from 'marked';
+
+// Local: relative paths with explicit .mjs extension
+import {consoleLogColored} from '../utils.mjs';
+import Config from './config.mjs';
+```
+
+- Prefer named imports over namespace imports.
+- Default imports are used for classes/singletons (e.g., `Config`, `path`).
+- Group imports: Node built-ins first, then third-party, then local (separated by blank lines).
+
+### Export Conventions
+
+Modules typically provide both named and default exports:
+
+```js
+const clean = async dirs => { /* ... */ };
+export {clean};
+export default clean;
+```
+
+### Naming Conventions
+
+| Entity | Convention | Examples |
+|--------|-----------|----------|
+| Variables, functions, params | camelCase | `getTargetPathString`, `srcPaths` |
+| Classes | PascalCase | `Config` |
+| Constants | camelCase (not SCREAMING_SNAKE) | `taskName`, `defaultConfig` |
+| Files | kebab-case with `.mjs` | `set-env-dev.mjs`, `is-prod.mjs` |
+| Test files | `*.test.mjs` | `util.test.mjs`, `config.test.mjs` |
+
+### Types
+
+No TypeScript compiler is used. Types are defined via **JSDoc** in `lib/typedefs.mjs`:
+
+```js
+/**
+ * @typedef {Object} PathPart
+ * @property {string} assets Path for general static assets
+ * @property {string=} css Path for CSS files
+ */
+```
+
+Use `@param`, `@returns`, `@typedef`, and `@type` annotations for documenting
+function signatures and inline type hints:
+
+```js
+/** @type string[] */
+const negativePatterns = [];
+```
+
+### Error Handling
+
+- Use `try/catch` in async functions.
+- Log errors with `console.error()`.
+- Top-level entry point (`build.mjs`) catches with `.catch()` and calls `process.exit(1)`.
+- Inner functions log errors and allow graceful continuation where appropriate.
+
+### Async Patterns
+
+- `async/await` is the primary pattern.
+- `Promise.all()` for parallel operations (e.g., running styles + scripts + markdown concurrently).
+- `.then()` chaining for sequential task pipelines:
+  ```js
+  setEnvDev().then(tasks.clean).then(tasks.copy).then(paraDev);
+  ```
+- Arrow functions are the dominant function style.
+
+## Testing
+
+Tests use the **Node.js built-in test runner** (`node:test` module), not Jest or Vitest.
+
+### Test Structure
+
+```js
+import {suite, test} from 'node:test';
+import assert from 'node:assert/strict';
+
+void suite('SuiteName', () => {
+  test('descriptive test name', () => {
+    assert.strictEqual(actual, expected);
+  });
+
+  test('async test', async () => {
+    const result = await someAsyncFunc();
+    assert.strictEqual(result, expected);
+  });
+});
+```
+
+Key patterns:
+- Suites are wrapped with `void suite(...)` (the `void` suppresses the return value).
+- Use `node:assert/strict` -- always strict assertions.
+- Tests clean up after themselves (create/remove temp directories in `before`/`after`).
+- Test fixtures live in `test/fixtures/`.
+
+## Project Structure
+
+```
+build.mjs              CLI entry point (bin: sn-build)
+sn-config.mjs          Default project configuration
+lib/
+  config.mjs           Config loading, merging, path helpers
+  is-prod.mjs          NODE_ENV check helper
+  typedefs.mjs         JSDoc type definitions
+  utils.mjs            File I/O, glob helpers, console coloring
+  vars.mjs             Default configuration values
+  tasks/
+    clean.mjs          Remove target directories
+    copy.mjs           Copy static assets via glob
+    markdown.mjs       Convert .md -> .html (marked + nunjucks/jstmpl)
+    prototype.mjs      Generate static HTML pages from templates
+    scripts.mjs        Bundle JS/TS via esbuild
+    set-env-dev.mjs    Set NODE_ENV=development
+    set-env-prod.mjs   Set NODE_ENV=production
+    styles.mjs         Bundle CSS via esbuild
+test/
+  *.test.mjs           Test files
+  fixtures/            Test fixture data
+```
+
+## Changelog & Versioning
+
+The project follows [Semantic Versioning](https://semver.org/) and maintains a
+`CHANGELOG.md` in [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) format.

package/CHANGELOG.md

@@ -4,6 +4,25 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.27.0
+2026-02-12
+### Changed
+- Updated dependencies
+- Various code changes after AI (Opus 4.6) code review
+
+## 0.26.0
+2025-12-21
+### Removed
+- `del`, `cpy` and `globby` to prefer node's native features (`rm`, `cp` and `glob`)
+- `mocha` to prefer node's built-in test runner
+### Added
+- New experimental templating system `JSTmpl` as default
+- Parameter `--njk` to specify Nunjucks as template engine
+- Parameter `--debug` to show verbose information for "copy" and "markdown" tasks
+### Changed
+- Console outputs now with colors
+- Updated various dependencies
+
 ## 0.13.0
 2025-09-20
 ### Changed

package/build.mjs

@@ -1,52 +1,76 @@
 #!/usr/bin/env node
-
 import {argv} from 'node:process';
+import path from 'node:path';
 
-import Config from './lib/config.mjs';
+import './lib/typedefs.mjs';
+import config from './lib/config.mjs';
 
 import clean from './lib/tasks/clean.mjs';
 import copy from './lib/tasks/copy.mjs';
-import markdown from './lib/tasks/markdown.mjs';
-import prototype from './lib/tasks/prototype.mjs';
+import {markdown, markdown2} from './lib/tasks/markdown.mjs';
+import {prototype, prototype2} from './lib/tasks/prototype.mjs';
 import scripts from './lib/tasks/scripts.mjs';
 import setEnvDev from './lib/tasks/set-env-dev.mjs';
 import setEnvProd from './lib/tasks/set-env-prod.mjs';
 import styles from './lib/tasks/styles.mjs';
+import {consoleLogColored} from './lib/utils.mjs';
 
 const taskName = argv[2]?.toLowerCase() || 'dev';
+const useNjk = argv.includes('--njk');
+const debug = argv.includes('--debug');
+
+if (debug) {
+  process.env.SN_BUILD_MODE = 'debug';
+}
 
 // load config data
-const conf = await Config.loadConfig();
+const conf = await config.loadConfig();
 
 const taskEnded = taskName => {
   console.timeEnd(taskName);
 };
 
-const srcPaths = Config.getSourcePaths(conf.sourcePath, conf.sourceRoot);
-const tgtPaths = Config.getTargetPaths(conf.targetPath, conf.targetRoot, conf.targetAssetsRoot);
+const srcPaths = config.getSourcePaths(conf.sourcePath, path.normalize(conf.sourceRoot));
+const tgtPaths = config.getTargetPaths(conf.targetPath, path.normalize(conf.targetRoot), conf.targetAssetsRoot);
 
 // Set parameters of each task
 const tasks = {
-  clean: () => clean([`${conf.targetRoot}/*`]),
+  clean: () => clean([conf.targetRoot]),
   copy: () => copy([
-    {sources: [`${conf.sourceRoot}/*`, `!${conf.sourceRoot}/*.d.ts`], target: conf.targetRoot},
-    {sources: `${srcPaths.assets}/**/*`, target: tgtPaths.assets},
-    {sources: `${srcPaths.modules}/**/assets/**/*`, target: tgtPaths.moduleAssets},
-    {sources: `${srcPaths.markdown}/**/assets/**/*`, target: tgtPaths.markdown}
-  ].concat(Config.getCopyPairs(conf.copyPairs, conf.sourceRoot, tgtPaths.assets))),
+    // Root2root: src/main/webapp/index.html -> tgt/static/index.html
+    {sources: [`${conf.sourceRoot}/*.*`, `!${conf.sourceRoot}/*.d.ts`], target: conf.targetRoot, opts: {flat: true}},
+    // Assets: src/main/webapp/assets/dummy.txt -> tgt/static/assets/_sn_/dummy.txt
+    {sources: `${srcPaths.assets}/**/*.*`, target: tgtPaths.assets, opts: {levelRemoval: 4}},
+    // Module assets:
+    // src/main/webapp/modules/mod-weather/assets/weather/sample.json -> tgt/static/assets/_sn_/modules/mod-weather/assets/weather/sample.json
+    {sources: `${srcPaths.modules}/**/assets/**/*.*`, target: tgtPaths.moduleAssets, opts: {levelRemoval: 4}},
+    // Markdown file assets
+    // src/main/webapp/md/google-pixel-9/assets/cover.webp -> public/posts/google-pixel-9/assets/cover.webp
+    {sources: `${srcPaths.markdown}/**/assets/**/*.*`, target: tgtPaths.markdown, opts: {levelRemoval: 4}}
+  ].concat(config.getCopyPairs(conf.copyPairs, conf.sourceRoot, tgtPaths.assets))),
   markdown: () => markdown(
     srcPaths.markdown,
     [srcPaths.prototype, srcPaths.modules],
     conf.njkGlobals,
     tgtPaths.markdown
   ),
+  markdown2: () => markdown2(
+    srcPaths.markdown,
+    conf.njkGlobals,
+    tgtPaths.markdown
+  ),
   prototype: () => prototype(
     srcPaths.prototype,
     [srcPaths.modules],
     conf.njkGlobals,
     tgtPaths.prototype
   ),
-  scripts: () => scripts(Config.getScriptEntries(conf.moduleEntries, conf.mainEntryFile, srcPaths), tgtPaths.assets),
+  prototype2: () => prototype2(
+    srcPaths.prototype,
+    conf.njkGlobals,
+    tgtPaths.prototype
+  ),
+  scripts: () => scripts(config.getScriptEntries(conf.moduleEntries, conf.mainEntryFile, srcPaths), tgtPaths.assets),
   styles: () => styles([
     `${srcPaths.css}/brands/*.css`,
     `${srcPaths.css}/index.css`,
@@ -57,7 +81,7 @@ const tasks = {
 
 const paraDev = () => {
   return Promise.all([
-    tasks.markdown().then(tasks.prototype),
+    useNjk ? tasks.markdown().then(tasks.prototype) : tasks.markdown2().then(tasks.prototype2),
     tasks.styles(),
     tasks.scripts()
   ]);
@@ -65,7 +89,7 @@ const paraDev = () => {
 
 const paraProd = () => {
   return Promise.all([
-    tasks.markdown(),
+    useNjk ? tasks.markdown() : tasks.markdown2(),
     tasks.styles(),
     tasks.scripts()
   ]);
@@ -83,7 +107,9 @@ const taskMap = {
   'clean': tasks.clean,
   'copy': tasks.copy,
   'markdown': tasks.markdown,
+  'markdown2': tasks.markdown2,
   'prototype': tasks.prototype,
+  'prototype2': tasks.prototype2,
   'scripts': tasks.scripts,
   'setenvdev': setEnvDev,
   'setenvprod': setEnvProd,
@@ -94,10 +120,16 @@ const taskMap = {
 
 const task = taskMap[taskName];
 
-console.log('+++ SN Build +++');
+if (typeof task !== 'function') {
+  console.warn(`Task "${taskName}" not found or is not a function!`);
+  process.exit(1);
+}
+
+consoleLogColored('+++ SN Build +++', ['bold', 'blue']);
 console.time(taskName);
 console.log(`Task "${taskName}" started...`);
 task().then(() => {
+  console.log('Task ended.');
   taskEnded(taskName);
 }).catch(err => {
   console.error(err);

package/lib/config.mjs

@@ -14,7 +14,7 @@ class Config {
       const cf = configFile || `${cwd()}${this.customConfigFile}`;
       const mod = await import(cf);
       const customConf = mod.default;
-      return this.deepMergeConfObj(defaultConf, customConf);
+      return this.mergeConfObj(defaultConf, customConf);
     } catch (e) {
       // file not exist
       console.error('Error loading file: ', e);
@@ -22,9 +22,9 @@ class Config {
     }
   }
 
-  // keep nested obj values while merging
+  // keep nested obj values while merging (only merges one level deep)
   // e.g. {foo:{a:1,b:2}} merged with {foo:{b:3,c:4}} will be {foo:{a:1,b:3,c:4}}
-  deepMergeConfObj(defaultConf, customConf) {
+  mergeConfObj(defaultConf, customConf) {
     const conf = Object.assign({}, defaultConf);
     for (const [k, v] of Object.entries(customConf)) {
       if (this.objsToMerge.includes(k)) {
@@ -89,12 +89,13 @@ class Config {
    */
   getCopyPairs = (copyPairs, sourceBase, targetBase, appendSourcePath = false) => {
     if (copyPairs && Array.isArray(copyPairs) && copyPairs.length > 0) {
-      return copyPairs.map(pr => {
+      return copyPairs.map(pair => {
+        const pc = {...pair};
         if (appendSourcePath) {
-          pr.sources = `${appendSourcePath}${pr.sources}`;
+          pc.sources = `${sourceBase}${pc.sources}`;
         }
-        pr.target = `${targetBase}${pr.target}`;
-        return pr;
+        pc.target = `${targetBase}${pc.target}`;
+        return pc;
       });
     } else {
       return [];

package/lib/is-prod.mjs

@@ -1,3 +1,5 @@
-export default function() {
-  return (process.env.NODE_ENV === 'production');
-}
+import {env} from 'node:process';
+
+const isProd = () => env.NODE_ENV === 'production';
+
+export default isProd;

package/lib/tasks/clean.mjs

@@ -1,14 +1,19 @@
-import {deleteAsync} from 'del';
+import {rm} from 'node:fs/promises';
+import {consoleLogColored} from '../utils.mjs';
 
 /**
  * Clean the target directory
  *
+ * @example
+ * await clean('target');
+ *
  * @param {(string|string[])} targetPath
- * @returns {Promise<string[]>}
+ * @returns {Promise<Awaited<void>[]>}
  */
 const clean = targetPath => {
-  console.log('=> clean');
-  return deleteAsync(targetPath);
+  consoleLogColored('=> clean');
+  let pa = (Array.isArray(targetPath)) ? targetPath : [targetPath];
+  return Promise.all(pa.map(path => rm(path, {force: true, recursive: true})));
 };
 
 export {clean};

package/lib/tasks/copy.mjs

@@ -1,15 +1,61 @@
-import cpy from 'cpy';
+import {cp} from 'node:fs/promises';
+import path from 'node:path';
+import {glob2Array, consoleLogColored, isDebugMode} from '../utils.mjs';
 
 /**
  * Copy (different) assets
  *
  * @param {STPair[]} sourceTargetPairs
- * @return {Promise<Awaited<unknown>[]>}
+ * @return {Promise<Awaited<Awaited<void>[]>[]>}
  */
 const copy = sourceTargetPairs => {
-  console.log('=> copy');
-  return Promise.all(sourceTargetPairs.map(pair => cpy(pair.sources, pair.target, pair.opts)));
+  consoleLogColored('=> copy');
+  const debug = isDebugMode();
+  return Promise.all(sourceTargetPairs.map(pair => globCopy(pair.sources, pair.target, pair.opts, debug)));
 };
 
-export {copy};
+/**
+ * Copy files specified as glob pattern(s)
+ *
+ * @param {string|string[]} globPatterns
+ * @param {string} targetRoot
+ * @param {CopyTaskOption} opts
+ * @param {boolean} verbose
+ * @returns {Promise<Awaited<void>[]>}
+ */
+const globCopy = async (globPatterns, targetRoot, opts, verbose = false) => {
+  /** @type string[] */
+  const sources = await glob2Array(globPatterns);
+
+  return Promise.all(sources.map(async src => {
+    const targetPath = opts.flat
+      ? path.join(targetRoot, path.basename(src))
+      : path.join(targetRoot, genTargetPath(src, opts.levelRemoval));
+    if (verbose) {
+      consoleLogColored(`copying ${src} -> ${targetPath}`, 'dim');
+    }
+    return cp(src, targetPath, {recursive: true});
+  }));
+};
+
+/**
+ * Generate the target path (destination) of the file to be copied
+ *
+ * @example
+ * genTargetPath('src/foo/bar/a.txt', 2)
+ * // returns 'bar/a.txt', 2 levels of path (src/foo) are removed
+ *
+ * @param {string} sourcePath
+ * @param {number=} levelRemoval How many levels of path to be removed
+ * @returns {string}
+ */
+const genTargetPath = (sourcePath, levelRemoval = 0) => {
+  const pathParts = sourcePath.split(path.sep);
+  const pathPartsCount = pathParts.length - 1;
+  const removal = levelRemoval ? Math.min(levelRemoval, pathPartsCount) : pathPartsCount;
+  const newPathParts = pathParts.slice(removal);
+  return newPathParts.join(path.sep);
+};
+
+export {copy, genTargetPath};
 export default copy;

package/lib/tasks/markdown.mjs

@@ -1,25 +1,22 @@
-import {globby} from 'globby';
 import {readFile} from 'node:fs/promises';
 import {marked} from 'marked';
 import {markedHighlight} from 'marked-highlight';
 import {markedXhtml} from 'marked-xhtml';
 import hljs from 'highlight.js';
 import njk from 'nunjucks';
+import {renderPageToString} from '@changke/jstmpl';
+import {createAndWriteToFile, getTargetPathString, glob2Array, consoleLogColored, isDebugMode} from '../utils.mjs';
 
-import {createAndWriteToFile, getTargetPathString} from '../utils.mjs';
-
-marked.use({
-  headerIds: false,
-  mangle: false
-},
-markedXhtml(),
-markedHighlight({
-  langPrefix: 'hljs language-',
-  highlight: (code, lang) => {
-    const language = hljs.getLanguage(lang) ? lang : 'plaintext';
-    return hljs.highlight(code, {language}).value;
-  }
-}));
+marked.use(
+  markedXhtml(),
+  markedHighlight({
+    langPrefix: 'hljs language-',
+    highlight: (code, lang) => {
+      const language = hljs.getLanguage(lang) ? lang : 'plaintext';
+      return hljs.highlight(code, {language}).value;
+    }
+  })
+);
 
 const {Environment, FileSystemLoader} = njk;
 
@@ -39,6 +36,8 @@ const getPageTitle = content => {
   return t;
 };
 
+const mdArticleTemplateFile = 'md.tmpl.mjs'; // TODO: configurable?
+
 /**
  * Generate docs using markdown and Nunjucks
  *
@@ -49,8 +48,8 @@ const getPageTitle = content => {
  * @return {Promise<string[]>}
  */
 const markdown = (mdSourcePathRoot, njkPaths, njkGlobals, mdTargetPath) => {
-  console.log('=> markdown');
-  return globby(`${mdSourcePathRoot}/**/*.md`).then(docs => {
+  consoleLogColored('=> markdown (njk)');
+  return glob2Array(`${mdSourcePathRoot}/**/*.md`).then(docs => {
     const njkEnv = new Environment(new FileSystemLoader(njkPaths, {}));
     for (const [k, v] of Object.entries(njkGlobals)) {
       njkEnv.addGlobal(k, v);
@@ -85,5 +84,42 @@ const markdown = (mdSourcePathRoot, njkPaths, njkGlobals, mdTargetPath) => {
   });
 };
 
-export {markdown};
+const markdown2 = (mdSourcePathRoot, data, mdTargetPath) => {
+  const debug = isDebugMode();
+  consoleLogColored('=> markdown2 (jstmpl)');
+  return glob2Array(`${mdSourcePathRoot}/**/*.md`).then(docs => {
+    return Promise.all(docs.map(async doc => {
+      const mdContent = await readFile(doc, {encoding: 'utf8'});
+      const mdHtml = marked.parse(mdContent);
+      const pageTitle = getPageTitle(mdContent);
+      const res = await renderPageToString(`${mdSourcePathRoot}/${mdArticleTemplateFile}`, {
+        ...data,
+        title: pageTitle,
+        content: mdHtml
+      });
+      const target = getTargetPathString(
+        doc,
+        mdSourcePathRoot,
+        mdTargetPath,
+        'md',
+        'html'
+      );
+      if (debug) {
+        consoleLogColored(`md: ${doc} -> ${target}`, 'dim');
+      }
+      await createAndWriteToFile(target, res);
+      // create a content-only file for RSS generating
+      const feedTarget = getTargetPathString(
+        doc,
+        mdSourcePathRoot,
+        mdTargetPath,
+        'md',
+        'txt'
+      );
+      await createAndWriteToFile(feedTarget, mdHtml);
+    }));
+  });
+};
+
+export {markdown, markdown2};
 export default markdown;

package/lib/tasks/prototype.mjs

@@ -1,8 +1,7 @@
 import njk from 'nunjucks';
-import {globby} from 'globby';
 import {readFile} from 'node:fs/promises';
-
-import {getTargetPathString, createAndWriteToFile} from '../utils.mjs';
+import {renderPageToString} from '@changke/jstmpl';
+import {getTargetPathString, createAndWriteToFile, glob2Array, consoleLogColored} from '../utils.mjs';
 
 const {Environment, FileSystemLoader} = njk;
 
@@ -16,8 +15,8 @@ const {Environment, FileSystemLoader} = njk;
  * @return {Promise<string[]>}
  */
 const prototype = (prototypeSourcePathRoot, njkPaths, njkGlobals, prototypeTargetPath) => {
-  console.log('=> prototype');
-  return globby(`${prototypeSourcePathRoot}/pages/**/*.njk`).then(pages => {
+  consoleLogColored('=> prototype (njk)');
+  return glob2Array(`${prototypeSourcePathRoot}/pages/**/*.njk`).then(pages => {
     const njkEnv = new Environment(new FileSystemLoader([prototypeSourcePathRoot].concat(njkPaths), {}));
     for (const [k, v] of Object.entries(njkGlobals)) {
       njkEnv.addGlobal(k, v);
@@ -37,5 +36,30 @@ const prototype = (prototypeSourcePathRoot, njkPaths, njkGlobals, prototypeTarge
   });
 };
 
-export {prototype};
+/**
+ * Generate static pages with JSTmpl
+ * @param {string} sourceRoot - Glob pattern for source files e.g. 'src/pages/*.mjs'
+ * @param {Object.<string, string>} data
+ * @param {string} targetPath
+ * @returns {Promise<void>}
+ */
+const prototype2 = (sourceRoot, data, targetPath) => {
+  consoleLogColored('=> prototype (jstmpl)');
+  // src/main/webapp/prototype/pages/index.mjs -> ${targetPath.prototype}/index.html
+  return glob2Array(`${sourceRoot}/pages/**/*.mjs`).then(pages => {
+    return Promise.all(pages.map(async page => {
+      const res = await renderPageToString(page, data);
+      const targetFile = getTargetPathString(
+        page,
+        `${sourceRoot}/pages`,
+        targetPath,
+        'mjs',
+        page.endsWith('rss/index.mjs') ? 'xml' : 'html'
+      );
+      await createAndWriteToFile(targetFile, res);
+    }));
+  });
+};
+
+export {prototype, prototype2};
 export default prototype;

package/lib/tasks/scripts.mjs

@@ -1,6 +1,6 @@
 import {build} from 'esbuild';
-
 import isEnvProd from '../is-prod.mjs';
+import {consoleLogColored} from '../utils.mjs';
 
 /**
  * Transpile / bundle JS files using esbuild
@@ -10,12 +10,12 @@ import isEnvProd from '../is-prod.mjs';
  * @return {Promise}
  */
 const esm = (entries, targetPath) => {
-  console.log('=> scripts');
+  consoleLogColored('=> scripts');
   return build({
     entryPoints: entries,
     bundle: true,
     format: 'esm',
-    target: 'es2023',
+    target: 'es2024',
     splitting: true,
     outdir: targetPath,
     minify: isEnvProd(), // only minify in prod build

package/lib/tasks/set-env-dev.mjs

@@ -1,8 +1,5 @@
-const setEnvDev = () => {
-  return new Promise(resolve => {
-    process.env.NODE_ENV = 'development';
-    resolve();
-  });
+const setEnvDev = async () => {
+  process.env.NODE_ENV = 'development';
 };
 
 export default setEnvDev;

package/lib/tasks/set-env-prod.mjs

@@ -1,8 +1,5 @@
-const setEnvProd = () => {
-  return new Promise(resolve => {
-    process.env.NODE_ENV = 'production';
-    resolve();
-  });
+const setEnvProd = async () => {
+  process.env.NODE_ENV = 'production';
 };
 
 export default setEnvProd;

package/lib/tasks/styles.mjs

@@ -1,6 +1,5 @@
 import {build} from 'esbuild';
-import {globby} from 'globby';
-
+import {glob2Array, consoleLogColored} from '../utils.mjs';
 import isEnvProd from '../is-prod.mjs';
 
 /**
@@ -12,16 +11,16 @@ import isEnvProd from '../is-prod.mjs';
  * @return {Promise}
  */
 const styles = (sources, targetPath, external = []) => {
-  console.log('=> styles');
-  return globby(sources).then(entries => {
+  consoleLogColored('=> styles');
+  return glob2Array(sources).then(entries => {
     return build({
       entryPoints: entries,
       bundle: true,
-      target: 'es2021',
+      target: 'es2024',
       outdir: targetPath,
       sourcemap: !isEnvProd(),
       minify: isEnvProd(),
-      external: external
+      external
     });
   });
 };

package/lib/typedefs.mjs

@@ -14,13 +14,21 @@
  * @property {string=} markdown Path for markdown files
  */
 
+/**
+ * Options for "copy" task
+ *
+ * @typedef {Object} CopyTaskOption
+ * @property {number=} levelRemoval
+ * @property {boolean=} flat
+ */
+
 /**
  * Source/Target pairs for "copy" task
  *
  * @typedef {Object} STPair
  * @property {(string|string[])} sources
  * @property {string} target
- * @property {Object=} opts
+ * @property {CopyTaskOption=} opts
  */
 
 /**

package/lib/utils.mjs

@@ -1,5 +1,7 @@
-import {access, mkdir, writeFile} from 'node:fs/promises';
-import * as path from 'node:path';
+import {access, mkdir, writeFile, glob, rm, stat} from 'node:fs/promises';
+import path from 'node:path';
+import {styleText} from 'node:util';
+import {env} from 'node:process';
 
 const getTargetPathString = (sourcePath, sourceRoot, targetRoot, srcExt, tgtExt) => {
   const baseName = path.basename(sourcePath, `.${srcExt}`);
@@ -17,7 +19,98 @@ const createAndWriteToFile = async (filePath, fileContent) => {
   await writeFile(filePath, fileContent, {flag: 'w+'});
 };
 
+/**
+ * Extracts negative patterns into another array to feed Node's glob function
+ * @param {(string|string[])} globPatterns
+ * @returns {Object.<string, string[]>}
+ */
+const processGlobPatterns = globPatterns => {
+  // extract negative patterns
+  let patterns = globPatterns;
+  if (!Array.isArray(globPatterns)) {
+    patterns = [globPatterns];
+  }
+  /** @type string[] */
+  const negativePatterns = [];
+  /** @type string[] */
+  const normalPatterns = patterns.filter(p => {
+    if (p.startsWith('!')) {
+      negativePatterns.push(p.substring(1));
+      return false;
+    } else {
+      return true;
+    }
+  });
+  return {normalPatterns, negativePatterns};
+};
+
+/**
+ * Convert `glob()` result to an array
+ * @param {(string|string[])} globPatterns
+ * @param {boolean} fileOnly
+ * @returns {Promise<string[]>}
+ */
+const glob2Array = async (globPatterns, fileOnly = false) => {
+  const p = processGlobPatterns(globPatterns);
+  const m = glob(p.normalPatterns, {exclude: p.negativePatterns});
+  if (fileOnly) {
+    const files = [];
+    return Array.fromAsync(m).then(async entries => {
+      for (const entry of entries) {
+        const st = await stat(entry);
+        if (st.isFile()) {
+          files.push(entry);
+        }
+      }
+      return files;
+    });
+  } else {
+    return Array.fromAsync(m);
+  }
+};
+
+const createDirectory = async (dir, log = false) => {
+  try {
+    const dirUrl = new URL(dir, import.meta.url);
+    const createdDir = await mkdir(dirUrl, {recursive: true});
+    if (log) {
+      console.log(`Directory created: ${createdDir}`);
+    }
+    return createdDir;
+  } catch (err) {
+    console.error(err.message);
+  }
+};
+
+const removeDirectory = async (dir, log = false) => {
+  try {
+    await rm(dir, {recursive: true, force: true});
+    if (log) {
+      console.log(`Directory removed: ${dir}`);
+    }
+  } catch (err) {
+    console.error(err.message);
+  }
+};
+
+/**
+ * Print colored console messages
+ * @param {string} msg
+ * @param {(string|string[])} color
+ */
+const consoleLogColored = (msg, color = 'cyan') => {
+  console.log(styleText(color, msg));
+};
+
+const isDebugMode = () => (env.SN_BUILD_MODE === 'debug');
+
 export {
   getTargetPathString,
-  createAndWriteToFile
+  createAndWriteToFile,
+  processGlobPatterns,
+  glob2Array,
+  createDirectory,
+  removeDirectory,
+  consoleLogColored,
+  isDebugMode
 };

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@changke/staticnext-build",
-  "version": "0.13.0",
+  "version": "0.27.0",
   "description": "Build scripts extracted from StaticNext seed project",
   "main": "index.js",
   "scripts": {
     "lint": "eslint . lib test",
-    "test": "mocha",
+    "test": "node --test 'test/*.test.mjs'",
     "prepublishOnly": "npm run lint && npm run test"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22.14.0"
   },
   "bin": {
     "sn-build": "build.mjs"
@@ -19,21 +19,18 @@
   "license": "ISC",
   "type": "module",
   "devDependencies": {
-    "@eslint/js": "^9.36.0",
-    "@stylistic/eslint-plugin": "^5.4.0",
-    "eslint": "^9.36.0",
-    "globals": "^16.4.0",
-    "mocha": "^11.7.2"
+    "@eslint/js": "^9.39.2",
+    "@stylistic/eslint-plugin": "^5.8.0",
+    "eslint": "^9.39.2",
+    "globals": "^16.5.0"
   },
   "dependencies": {
-    "cpy": "^12.0.1",
-    "del": "^8.0.1",
-    "esbuild": "^0.25.10",
-    "globby": "^14.1.0",
+    "@changke/jstmpl": "^0.0.1",
+    "esbuild": "^0.27.3",
     "highlight.js": "^11.11.1",
-    "marked": "^16.3.0",
-    "marked-highlight": "^2.2.2",
-    "marked-xhtml": "^1.0.13",
+    "marked": "^17.0.2",
+    "marked-highlight": "^2.2.3",
+    "marked-xhtml": "^1.0.14",
     "nunjucks": "^3.2.4"
   }
 }

package/eslint.config.mjs

@@ -1,30 +0,0 @@
-import globals from 'globals';
-import js from '@eslint/js';
-import stylistic from '@stylistic/eslint-plugin';
-
-export default [
-  js.configs.recommended,
-  stylistic.configs.customize({
-    blockSpacing: false,
-    braceStyle: '1tbs',
-    semi: true
-  }),
-  {
-    files: ['**/*.mjs'],
-    languageOptions: {
-      globals: {
-        ...globals.node,
-        ...globals.mocha
-      }
-    },
-    rules: {
-      '@stylistic/arrow-parens': ['error', 'as-needed', {requireForBlockBody: false}],
-      '@stylistic/comma-dangle': ['error', 'never'],
-      '@stylistic/object-curly-spacing': ['error', 'never'],
-      '@stylistic/quotes': ['warn', 'single'],
-      '@stylistic/quote-props': 0,
-      '@stylistic/semi': ['error', 'always'],
-      '@stylistic/space-before-function-paren': ['error', {anonymous: 'ignore', asyncArrow: 'always', named: 'never'}]
-    }
-  }
-];