@changke/staticnext-build 0.13.0 → 0.26.1

package/CHANGELOG.md

@@ -4,6 +4,19 @@ 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.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,19 +1,27 @@
 #!/usr/bin/env node
-
 import {argv} from 'node:process';
+import path from 'node:path';
 
+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();
@@ -22,17 +30,23 @@ 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}
+    // 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,
@@ -40,12 +54,22 @@ const tasks = {
     conf.njkGlobals,
     tgtPaths.markdown
   ),
+  markdown2: () => markdown2(
+    srcPaths.markdown,
+    conf.njkGlobals,
+    tgtPaths.markdown
+  ),
   prototype: () => prototype(
     srcPaths.prototype,
     [srcPaths.modules],
     conf.njkGlobals,
     tgtPaths.prototype
   ),
+  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`,
@@ -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,11 @@ const taskMap = {
 
 const task = taskMap[taskName];
 
-console.log('+++ SN Build +++');
+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/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,64 @@
-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);
+
+  let targetPath = '';
+  return Promise.all(sources.map(async src => {
+    if (opts.flat) {
+      targetPath = path.join(targetRoot, path.basename(src));
+    } else {
+      targetPath = 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,12 +1,11 @@
-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 {createAndWriteToFile, getTargetPathString} from '../utils.mjs';
+import {renderPageToString} from '@changke/jstmpl';
+import {createAndWriteToFile, getTargetPathString, glob2Array, consoleLogColored, isDebugMode} from '../utils.mjs';
 
 marked.use({
   headerIds: false,
@@ -39,6 +38,8 @@ const getPageTitle = content => {
   return t;
 };
 
+const mdArticleTemplateFile = 'md.tmpl.mjs'; // TODO: configurable?
+
 /**
  * Generate docs using markdown and Nunjucks
  *
@@ -49,8 +50,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 +86,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/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,12 +11,12 @@ 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(),

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.26.1",
   "description": "Build scripts extracted from StaticNext seed project",
   "main": "index.js",
   "scripts": {
     "lint": "eslint . lib test",
-    "test": "mocha",
+    "test": "node --test",
     "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.6.1",
+    "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.2",
     "highlight.js": "^11.11.1",
-    "marked": "^16.3.0",
-    "marked-highlight": "^2.2.2",
-    "marked-xhtml": "^1.0.13",
+    "marked": "^17.0.1",
+    "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'}]
-    }
-  }
-];