basecampjs 0.0.6 → 0.0.8

package/index.js

@@ -2,13 +2,15 @@
 import { argv, exit } from "process";
 import { createServer } from "http";
 import { existsSync } from "fs";
-import { cp, mkdir, readFile, readdir, rm, stat, writeFile } from "fs/promises";
+import { cp, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "fs/promises";
 import { basename, dirname, extname, join, relative, resolve } from "path";
 import { pathToFileURL } from "url";
+import { createHash } from "crypto";
 import * as kolor from "kolorist";
 import chokidar from "chokidar";
 import matter from "gray-matter";
 import MarkdownIt from "markdown-it";
+import Mustache from "mustache";
 import nunjucks from "nunjucks";
 import { Liquid } from "liquidjs";
 import { minify as minifyCss } from "csso";
@@ -25,7 +27,8 @@ const defaultConfig = {
   markdown: true,
   minifyCSS: false,
   minifyHTML: false,
-  integrations: { nunjucks: true, liquid: false, vue: false, alpine: false }
+  cacheBustAssets: false,
+  integrations: { nunjucks: true, liquid: false, mustache: false, vue: false, alpine: false }
 };
 
 async function loadConfig(root) {
@@ -45,18 +48,23 @@ async function ensureDir(dir) {
   await mkdir(dir, { recursive: true });
 }
 
-async function loadData(dataDir) {
+async function loadData(dataDirs) {
   const collections = {};
-  if (!existsSync(dataDir)) return collections;
-  const files = await walkFiles(dataDir);
-  for (const file of files) {
-    if (extname(file).toLowerCase() !== ".json") continue;
-    const name = basename(file, ".json");
-    try {
-      const raw = await readFile(file, "utf8");
-      collections[name] = JSON.parse(raw);
-    } catch (err) {
-      console.error(kolor.red(`Failed to load data ${relative(dataDir, file)}: ${err.message}`));
+  // Support both string and array input
+  const dirs = Array.isArray(dataDirs) ? dataDirs : [dataDirs];
+  
+  for (const dataDir of dirs) {
+    if (!existsSync(dataDir)) continue;
+    const files = await walkFiles(dataDir);
+    for (const file of files) {
+      if (extname(file).toLowerCase() !== ".json") continue;
+      const name = basename(file, ".json");
+      try {
+        const raw = await readFile(file, "utf8");
+        collections[name] = JSON.parse(raw);
+      } catch (err) {
+        console.error(kolor.red(`Failed to load data ${relative(dataDir, file)}: ${err.message}`));
+      }
     }
   }
   return collections;
@@ -175,7 +183,7 @@ function shouldRenderMarkdown(frontmatter, config, defaultValue) {
   return defaultValue;
 }
 
-async function renderWithLayout(layoutName, html, ctx, env, liquidEnv) {
+async function renderWithLayout(layoutName, html, ctx, env, liquidEnv, layoutsDir) {
   if (!layoutName) return html;
   const ext = extname(layoutName).toLowerCase();
   const layoutCtx = {
@@ -193,6 +201,14 @@ async function renderWithLayout(layoutName, html, ctx, env, liquidEnv) {
     return liquidEnv.renderFile(layoutName, layoutCtx);
   }
 
+  if (ext === ".mustache") {
+    const layoutPath = join(layoutsDir, layoutName);
+    if (existsSync(layoutPath)) {
+      const layoutTemplate = await readFile(layoutPath, "utf8");
+      return Mustache.render(layoutTemplate, layoutCtx);
+    }
+  }
+
   // Unknown layout type, return unwrapped content
   return html;
 }
@@ -210,7 +226,7 @@ async function renderPage(filePath, { pagesDir, layoutsDir, outDir, env, liquidE
     const parsed = matter(raw);
     const html = md.render(parsed.content);
     const ctx = pageContext(parsed.data, html, config, rel, data, path);
-    const rendered = await renderWithLayout(parsed.data.layout, html, ctx, env, liquidEnv);
+    const rendered = await renderWithLayout(parsed.data.layout, html, ctx, env, liquidEnv, layoutsDir);
     await writeFile(outPath, rendered, "utf8");
     return;
   }
@@ -224,7 +240,7 @@ async function renderPage(filePath, { pagesDir, layoutsDir, outDir, env, liquidE
     if (shouldRenderMarkdown(parsed.data, config, false)) {
       pageHtml = md.render(pageHtml);
     }
-    const rendered = await renderWithLayout(parsed.data.layout, pageHtml, ctx, env, liquidEnv);
+    const rendered = await renderWithLayout(parsed.data.layout, pageHtml, ctx, env, liquidEnv, layoutsDir);
     await writeFile(outPath, rendered, "utf8");
     return;
   }
@@ -237,7 +253,20 @@ async function renderPage(filePath, { pagesDir, layoutsDir, outDir, env, liquidE
     if (shouldRenderMarkdown(parsed.data, config, false)) {
       pageHtml = md.render(pageHtml);
     }
-    const rendered = await renderWithLayout(parsed.data.layout, pageHtml, ctx, env, liquidEnv);
+    const rendered = await renderWithLayout(parsed.data.layout, pageHtml, ctx, env, liquidEnv, layoutsDir);
+    await writeFile(outPath, rendered, "utf8");
+    return;
+  }
+
+  if (ext === ".mustache") {
+    const raw = await readFile(filePath, "utf8");
+    const parsed = matter(raw);
+    const ctx = pageContext(parsed.data, parsed.content, config, rel, data, path);
+    let pageHtml = Mustache.render(parsed.content, ctx);
+    if (shouldRenderMarkdown(parsed.data, config, false)) {
+      pageHtml = md.render(pageHtml);
+    }
+    const rendered = await renderWithLayout(parsed.data.layout, pageHtml, ctx, env, liquidEnv, layoutsDir);
     await writeFile(outPath, rendered, "utf8");
     return;
   }
@@ -250,7 +279,7 @@ async function renderPage(filePath, { pagesDir, layoutsDir, outDir, env, liquidE
     if (shouldRenderMarkdown(parsed.data, config, false)) {
       pageHtml = md.render(pageHtml);
     }
-    const rendered = await renderWithLayout(parsed.data.layout, pageHtml, ctx, env, liquidEnv);
+    const rendered = await renderWithLayout(parsed.data.layout, pageHtml, ctx, env, liquidEnv, layoutsDir);
     await writeFile(outPath, rendered, "utf8");
     return;
   }
@@ -258,6 +287,88 @@ async function renderPage(filePath, { pagesDir, layoutsDir, outDir, env, liquidE
   await cp(filePath, outPath);
 }
 
+async function cacheBustAssets(outDir) {
+  const assetMap = {}; // original path -> hashed path
+  const files = await walkFiles(outDir);
+  const assetFiles = files.filter((file) => {
+    const ext = extname(file).toLowerCase();
+    return ext === ".css" || ext === ".js";
+  });
+
+  // Hash and rename each asset
+  for (const file of assetFiles) {
+    try {
+      const content = await readFile(file);
+      const hash = createHash("sha256").update(content).digest("hex").slice(0, 10);
+      const ext = extname(file);
+      const base = basename(file, ext);
+      const dir = dirname(file);
+      const hashedName = `${base}-${hash}${ext}`;
+      const hashedPath = join(dir, hashedName);
+      
+      await rename(file, hashedPath);
+      
+      // Store mapping of original relative path to hashed relative path
+      const originalRel = relative(outDir, file).replace(/\\/g, "/");
+      const hashedRel = relative(outDir, hashedPath).replace(/\\/g, "/");
+      assetMap[originalRel] = hashedRel;
+      
+      // Log the cache-busted file
+      console.log(kolor.dim(`  ${originalRel}`) + kolor.cyan(` → `) + kolor.green(hashedRel));
+    } catch (err) {
+      console.error(kolor.red(`Failed to cache-bust ${relative(outDir, file)}: ${err.message}`));
+    }
+  }
+
+  // Update HTML files to reference hashed assets
+  const htmlFiles = files.filter((file) => extname(file).toLowerCase() === ".html");
+  
+  for (const htmlFile of htmlFiles) {
+    try {
+      let html = await readFile(htmlFile, "utf8");
+      let updated = false;
+
+      // Update <link> tags (CSS)
+      for (const [original, hashed] of Object.entries(assetMap)) {
+        if (original.endsWith(".css")) {
+          // Match href="/path" or href="path" but ensure we stay within the tag
+          const escaped = original.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          const pattern = new RegExp(`(<link[^>]*?\\shref=["'])/?${escaped}(["'])`, "gi");
+          
+          const newHtml = html.replace(pattern, `$1/${hashed}$2`);
+          if (newHtml !== html) {
+            html = newHtml;
+            updated = true;
+          }
+        }
+      }
+
+      // Update <script> tags (JS)
+      for (const [original, hashed] of Object.entries(assetMap)) {
+        if (original.endsWith(".js")) {
+          // Match src="/path" or src="path" but ensure we stay within the tag
+          const escaped = original.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          const pattern = new RegExp(`(<script[^>]*?\\ssrc=["'])/?${escaped}(["'])`, "gi");
+          
+          const newHtml = html.replace(pattern, `$1/${hashed}$2`);
+          if (newHtml !== html) {
+            html = newHtml;
+            updated = true;
+          }
+        }
+      }
+
+      if (updated) {
+        await writeFile(htmlFile, html, "utf8");
+      }
+    } catch (err) {
+      console.error(kolor.red(`Failed to update asset references in ${relative(outDir, htmlFile)}: ${err.message}`));
+    }
+  }
+
+  return assetMap;
+}
+
 async function build(cwdArg = cwd) {
   const config = await loadConfig(cwdArg);
   const srcDir = resolve(cwdArg, config.srcDir || "src");
@@ -265,11 +376,28 @@ async function build(cwdArg = cwd) {
   const layoutsDir = join(srcDir, "layouts");
   const partialsDir = join(srcDir, "partials");
   const dataDir = join(srcDir, "data");
+  const collectionsDir = join(srcDir, "collections");
   const publicDir = resolve(cwdArg, "public");
   const outDir = resolve(cwdArg, config.outDir || "dist");
   const env = createNunjucksEnv(layoutsDir, pagesDir, srcDir, partialsDir);
+  // Allow user config to extend the Nunjucks environment (e.g., custom filters)
+  if (config?.hooks?.nunjucksEnv && typeof config.hooks.nunjucksEnv === "function") {
+    try {
+      config.hooks.nunjucksEnv(env);
+    } catch (err) {
+      console.error(kolor.red(`Failed to apply nunjucksEnv hook: ${err.message}`));
+    }
+  }
   const liquidEnv = createLiquidEnv(layoutsDir, pagesDir, srcDir, partialsDir);
-  const data = await loadData(dataDir);
+  // Allow user config to extend the Liquid environment (e.g., custom filters)
+  if (config?.hooks?.liquidEnv && typeof config.hooks.liquidEnv === "function") {
+    try {
+      config.hooks.liquidEnv(liquidEnv);
+    } catch (err) {
+      console.error(kolor.red(`Failed to apply liquidEnv hook: ${err.message}`));
+    }
+  }
+  const data = await loadData([dataDir, collectionsDir]);
 
   await cleanDir(outDir);
   await copyPublic(publicDir, outDir);
@@ -292,6 +420,17 @@ async function build(cwdArg = cwd) {
     console.log(kolor.green("HTML minified"));
   }
 
+  if (config.cacheBustAssets) {
+    console.log(kolor.cyan("Cache-busting assets..."));
+    const assetMap = await cacheBustAssets(outDir);
+    const assetCount = Object.keys(assetMap).length;
+    if (assetCount > 0) {
+      console.log(kolor.green(`✓ Cache-busted ${assetCount} asset(s)`));
+    } else {
+      console.log(kolor.yellow("No assets found to cache-bust"));
+    }
+  }
+
   console.log(kolor.green(`Built ${files.length} page(s) → ${relative(cwdArg, outDir)}`));
 }
 
@@ -381,9 +520,10 @@ async function dev(cwdArg = cwd) {
   const config = await loadConfig(cwdArg);
   const srcDir = resolve(cwdArg, config.srcDir || "src");
   const dataDir = join(srcDir, "data");
+  const collectionsDir = join(srcDir, "collections");
   const publicDir = resolve(cwdArg, "public");
   const outDir = resolve(cwdArg, config.outDir || "dist");
-  const watcher = chokidar.watch([srcDir, publicDir, dataDir], { ignoreInitial: true });
+  const watcher = chokidar.watch([srcDir, publicDir, dataDir, collectionsDir], { ignoreInitial: true });
 
   watcher.on("all", (event, path) => {
     console.log(kolor.cyan(`↻ ${event}: ${relative(cwdArg, path)}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "basecampjs",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "type": "module",
   "description": "BasecampJS engine for CampsiteJS static site generator.",
   "bin": {
@@ -18,6 +18,7 @@
     "kolorist": "^1.8.0",
     "liquidjs": "^10.12.0",
     "markdown-it": "^14.1.0",
+    "mustache": "^4.2.0",
     "nunjucks": "^3.2.4"
   },
   "engines": {