basecampjs 0.0.5 → 0.0.7

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) {
@@ -128,18 +131,20 @@ async function walkFiles(dir) {
   return results;
 }
 
-function createNunjucksEnv(layoutsDir, pagesDir, srcDir) {
-  // Allow templates to resolve from layouts, pages, or the src root
+function createNunjucksEnv(layoutsDir, pagesDir, srcDir, partialsDir) {
+  // Allow templates to resolve from layouts, partials, pages, or the src root
+  const searchPaths = [layoutsDir, partialsDir, pagesDir, srcDir].filter(Boolean);
   return new nunjucks.Environment(
-    new nunjucks.FileSystemLoader([layoutsDir, pagesDir, srcDir], { noCache: true }),
+    new nunjucks.FileSystemLoader(searchPaths, { noCache: true }),
     { autoescape: false }
   );
 }
 
-function createLiquidEnv(layoutsDir, pagesDir, srcDir) {
+function createLiquidEnv(layoutsDir, pagesDir, srcDir, partialsDir) {
   // Liquid loader will search these roots for partials/layouts
+  const root = [layoutsDir, partialsDir, pagesDir, srcDir].filter(Boolean);
   return new Liquid({
-    root: [layoutsDir, pagesDir, srcDir],
+    root,
     extname: ".liquid",
     cache: false
   });
@@ -173,7 +178,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 = {
@@ -191,6 +196,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;
 }
@@ -208,7 +221,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;
   }
@@ -222,7 +235,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;
   }
@@ -235,7 +248,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;
   }
@@ -248,7 +274,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;
   }
@@ -256,16 +282,115 @@ 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");
   const pagesDir = join(srcDir, "pages");
   const layoutsDir = join(srcDir, "layouts");
+  const partialsDir = join(srcDir, "partials");
   const dataDir = join(srcDir, "data");
   const publicDir = resolve(cwdArg, "public");
   const outDir = resolve(cwdArg, config.outDir || "dist");
-  const env = createNunjucksEnv(layoutsDir, pagesDir, srcDir);
-  const liquidEnv = createLiquidEnv(layoutsDir, pagesDir, srcDir);
+  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);
+  // 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);
 
   await cleanDir(outDir);
@@ -289,6 +414,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)}`));
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "basecampjs",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "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": {