@daz4126/swifty 2.11.0 → 2.12.0

package/src/partials.js

@@ -1,76 +1,270 @@
 import fs from "fs/promises";
 import fsExtra from "fs-extra";
 import path from "path";
-import { dirs } from "./config.js";
+import { dirs, defaultConfig } from "./config.js";
 import { marked } from "marked";
+import { Eta } from "eta";
+import { loadData } from "./data.js";
 
 const partialCache = new Map();
+const imageExtensionRegex = /\.(png|jpe?g|webp)(?=([?#]|$))/i;
+const rewriteableImageTags = new Set(["a", "img", "source"]);
 
-const loadPartial = async (partialName) => {
+// Helper to escape HTML attribute values
+const escapeAttr = (str) => {
+  if (!str) return '';
+  return String(str)
+    .replace(/&/g, '&')
+    .replace(/"/g, '"')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+};
+
+// Count words in content (strips HTML and markdown)
+const countWords = (content) => {
+  if (!content) return 0;
+  // Strip HTML tags
+  let text = content.replace(/<[^>]*>/g, ' ');
+  // Strip markdown syntax (links, images, emphasis, etc.)
+  text = text.replace(/!?\[([^\]]*)\]\([^)]*\)/g, '$1'); // links/images
+  text = text.replace(/[*_~`#]+/g, ''); // emphasis, headers
+  text = text.replace(/\n/g, ' ');
+  // Split on whitespace and filter empty strings
+  const words = text.split(/\s+/).filter(word => word.length > 0);
+  return words.length;
+};
+
+// Calculate reading time using config value or default 200 words per minute
+const calculateReadingTime = (wordCount, wordsPerMinute = defaultConfig.words_per_minute || 200) => {
+  const minutes = Math.ceil(wordCount / wordsPerMinute);
+  return minutes === 1 ? '1 min read' : `${minutes} min read`;
+};
+
+// Generate Open Graph meta tags from page data
+const generateOgTags = (values) => {
+  const meta = values.meta || {};
+  const tags = [];
+
+  // Basic OG tags
+  const title = meta.title || values.title || '';
+  const sitename = meta.sitename || values.sitename || '';
+  const description = meta.description || meta.summary || '';
+  const url = values.url || '';
+  const siteUrl = (meta.site_url || values.site_url || '').replace(/\/$/, '');
+  const image = meta.image || meta.og_image || '';
+  const type = meta.og_type || (values.folder ? 'website' : 'article');
+  const author = meta.author || values.author || '';
+
+  // Open Graph tags
+  if (title) tags.push(`<meta property="og:title" content="${escapeAttr(title)}">`);
+  if (sitename) tags.push(`<meta property="og:site_name" content="${escapeAttr(sitename)}">`);
+  if (siteUrl && url) tags.push(`<meta property="og:url" content="${escapeAttr(siteUrl + url)}">`);
+  tags.push(`<meta property="og:type" content="${escapeAttr(type)}">`);
+  if (description) tags.push(`<meta property="og:description" content="${escapeAttr(description)}">`);
+  if (image) {
+    const imageUrl = image.startsWith('http') ? image : siteUrl + image;
+    tags.push(`<meta property="og:image" content="${escapeAttr(imageUrl)}">`);
+  }
+
+  // Twitter Card tags
+  tags.push(`<meta name="twitter:card" content="${image ? 'summary_large_image' : 'summary'}">`);
+  if (title) tags.push(`<meta name="twitter:title" content="${escapeAttr(title)}">`);
+  if (description) tags.push(`<meta name="twitter:description" content="${escapeAttr(description)}">`);
+  if (image) {
+    const imageUrl = image.startsWith('http') ? image : siteUrl + image;
+    tags.push(`<meta name="twitter:image" content="${escapeAttr(imageUrl)}">`);
+  }
+
+  // Article-specific tags
+  if (type === 'article') {
+    if (author) tags.push(`<meta property="article:author" content="${escapeAttr(author)}">`);
+    if (values.dateObj) {
+      tags.push(`<meta property="article:published_time" content="${values.dateObj.toISOString()}">`);
+    }
+    if (meta.tags && Array.isArray(meta.tags)) {
+      meta.tags.forEach(tag => {
+        tags.push(`<meta property="article:tag" content="${escapeAttr(tag)}">`);
+      });
+    }
+  }
+
+  return tags.join('\n  ');
+};
+
+// Configure Eta with useWith for cleaner variable access
+const eta = new Eta({
+  views: dirs.partials,
+  autoEscape: false,  // All output is raw (no HTML escaping)
+  autoTrim: false,
+  useWith: true,      // Allows direct variable access without 'it.' prefix
+});
+
+const loadPartialData = async (partialName) => {
   if (partialCache.has(partialName)) {
     return partialCache.get(partialName);
   }
 
-  const partialPath = path.join(dirs.partials, `${partialName}.md`);
-  if (await fsExtra.pathExists(partialPath)) {
+  const partialFiles = [
+    { path: path.join(dirs.partials, `${partialName}.md`), raw: false },
+    { path: path.join(dirs.partials, `${partialName}.html`), raw: true },
+  ];
+
+  for (const partialFile of partialFiles) {
+    const partialPath = partialFile.path;
+    if (!(await fsExtra.pathExists(partialPath))) continue;
+
     const partialContent = await fs.readFile(partialPath, "utf-8");
-    partialCache.set(partialName, partialContent); // Store in cache
-    return partialContent;
-  } else {
-    console.warn(`Include "${partialName}" not found.`);
-    return `<p>Include "${partialName}" not found.</p>`;
+    const partialData = { content: partialContent, raw: partialFile.raw };
+    partialCache.set(partialName, partialData);
+    return partialData;
   }
+
+  console.warn(`Include "${partialName}" not found.`);
+  return { content: `<p>Include "${partialName}" not found.</p>`, raw: true };
+};
+
+const loadPartial = async (partialName) => {
+  const partialData = await loadPartialData(partialName);
+  return partialData.content;
 };
 
+const shouldRewriteImageUrl = (url) => {
+  if (!url || !url.startsWith("/images/")) return false;
+  return imageExtensionRegex.test(url);
+};
+
+const rewriteImageUrl = (url) => {
+  if (!shouldRewriteImageUrl(url)) return url;
+  return url.replace(imageExtensionRegex, ".webp");
+};
+
+const rewriteSrcset = (srcset) =>
+  srcset
+    .split(",")
+    .map((candidate) => {
+      const parts = candidate.trim().split(/\s+/);
+      if (!parts[0]) return candidate;
+      return [rewriteImageUrl(parts[0]), ...parts.slice(1)].join(" ");
+    })
+    .join(", ");
+
+const rewriteLocalImageReferences = (html) =>
+  html.replace(/<([a-z][\w:-]*)(\s[^<>]*?)?>/gi, (tag, tagName) => {
+    const normalizedTagName = tagName.toLowerCase();
+    if (!rewriteableImageTags.has(normalizedTagName)) {
+      return tag;
+    }
+
+    return tag.replace(
+      /\s(src|href|srcset)=(["'])(.*?)\2/gi,
+      (attribute, attributeName, quote, value) => {
+        const nextValue =
+          attributeName.toLowerCase() === "srcset"
+            ? rewriteSrcset(value)
+            : rewriteImageUrl(value);
+        return ` ${attributeName}=${quote}${nextValue}${quote}`;
+      },
+    );
+  });
+
 const replacePlaceholders = async (template, values) => {
-  const partialRegex = /{{\s*partial:\s*([\w-]+)\s*}}/g;
-  const replaceAsync = async (str, regex, asyncFn) => {
-    const matches = [];
-    str.replace(regex, (match, ...args) => {
-      matches.push(asyncFn(match, ...args));
-      return match;
-    });
-    const results = await Promise.all(matches);
-    return str.replace(regex, () => results.shift());
+  // Default values for optional variables
+  const defaults = {
+    pagination: '',
+    breadcrumbs: '',
+    nav_links: '',
+    links_to_children: '',
+    links_to_siblings: '',
+    links_to_tags: '',
+    links_to_self_and_siblings: '',
+    content: '',
+    title: '',
+    sitename: '',
+    author: '',
+    date: '',
+    created_at: '',
+    updated_at: '',
+    og_tags: '',
+    word_count: 0,
+    reading_time: '',
+    prev_page: '',
+    next_page: '',
   };
 
-  // Protect code blocks BEFORE any placeholder replacement
-  // Fenced blocks require closing ``` to be at start of line (after newline)
+  // Load data files from data/ folder
+  const dataFiles = await loadData();
+
+  // Generate OG tags
+  const og_tags = generateOgTags(values);
+
+  // Calculate word count and reading time from content
+  const word_count = countWords(values.content);
+  const reading_time = calculateReadingTime(word_count);
+
+  // Build the data object for Eta
+  // Merge defaults, config values, page metadata, and computed values
+  const templateData = {
+    ...defaults,
+    ...values,
+    ...(values.meta || {}),
+    og_tags,
+    word_count,
+    reading_time,
+    // Expose page namespace with meta
+    page: {
+      ...defaults,
+      ...values,
+      ...(values.meta || {}),
+      meta: values.meta || {},
+      og_tags,
+      word_count,
+      reading_time,
+    },
+    // Expose data folder contents
+    data: dataFiles,
+  };
+
+  // Protect code blocks BEFORE Eta processing
   const codeBlockRegex =
     /```[\s\S]*?\n```|`[^`\n]+`|<(pre|code)[^>]*>[\s\S]*?<\/\1>/g;
   const codeBlocks = [];
   template = template.replace(codeBlockRegex, (match) => {
     codeBlocks.push(match);
-    return `{{CODE_BLOCK_${codeBlocks.length - 1}}}`; // Temporary placeholder
+    return `__CODE_BLOCK_${codeBlocks.length - 1}__`;
   });
 
-  // Replace partial includes (now only outside code blocks)
-  template = await replaceAsync(
-    template,
-    partialRegex,
-    async (match, partialName) => {
-      let partialContent = await loadPartial(partialName);
-      partialContent = await replacePlaceholders(partialContent, values); // Recursive replacement
-      return marked(partialContent); // Convert Markdown to HTML
-    },
-  );
+  // Handle <%= partial: name %> syntax
+  const partialRegex = /<%=\s*partial:\s*([\w-]+)\s*%>/g;
+  const partialMatches = [...template.matchAll(partialRegex)];
 
-  // Replace other placeholders outside of code blocks
-  template = template.replace(/{{\s*([^}\s]+)\s*}}/g, (match, key) => {
-    return values.data && key in values?.data
-      ? values.data[key]
-      : key in values
-        ? values[key]
-        : match;
-  });
+  for (const match of partialMatches) {
+    const [fullMatch, partialName] = match;
+    const partialData = await loadPartialData(partialName);
+    let partialContent = partialData.content;
+    partialContent = await replacePlaceholders(partialContent, values);
+    const renderedPartial = partialData.raw ? partialContent : marked(partialContent);
+    template = template.replace(fullMatch, renderedPartial);
+  }
+
+  // Convert <%- to <%= since autoEscape is false (all output is raw)
+  // This provides EJS-style syntax compatibility
+  template = template.replace(/<%-/g, '<%=');
+
+  // Render with Eta
+  try {
+    template = eta.renderString(template, templateData);
+  } catch (error) {
+    console.warn(`Eta template error: ${error.message}`);
+  }
 
   // Restore code blocks
   template = template.replace(
-    /{{CODE_BLOCK_(\d+)}}/g,
+    /__CODE_BLOCK_(\d+)__/g,
     (_, index) => codeBlocks[index],
   );
-  // replace image extensions with optimized extension
-  template = template.replace(/\.(png|jpe?g|webp)/gi, ".webp");
+
+  template = rewriteLocalImageReferences(template);
+
   return template;
 };
 

package/src/rss.js

@@ -57,8 +57,8 @@ const generateRssFeed = (feedConfig, pages, siteUrl) => {
   const items = feedPages
     .map((page) => {
       const itemUrl = `${siteUrl}${page.url}`;
-      const itemTitle = escapeXml(page.data?.title || page.title || page.name);
-      const itemDate = toRfc822(page.data?.date || page.updated_at || new Date());
+      const itemTitle = escapeXml(page.meta?.title || page.title || page.name);
+      const itemDate = toRfc822(page.meta?.date || page.updated_at || new Date());
       const itemDescription = escapeXml(
         truncate(stripHtml(page.content), 300)
       );
@@ -98,8 +98,10 @@ const findPagesInFolder = (pages, folderName) => {
         found.push(page);
       }
       // Recursively search nested pages
-      if (page.pages) {
-        searchPages(page.pages);
+      // Use allPages for paginated folders to include all items in RSS
+      const childPages = page.allPages || page.pages;
+      if (childPages) {
+        searchPages(childPages);
       }
     }
   };

package/src/sitemap.js

@@ -0,0 +1,89 @@
+import fs from "fs/promises";
+import fsExtra from "fs-extra";
+import path from "path";
+import { defaultConfig } from "./config.js";
+
+const escapeXml = (str) =>
+  String(str || "")
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+
+const formatSitemapDate = (date) => {
+  const parsed = date instanceof Date ? date : new Date(date);
+  return isNaN(parsed.getTime()) ? null : parsed.toISOString().slice(0, 10);
+};
+
+const flattenPages = (pages) => {
+  const flattened = [];
+
+  const addPages = (pageList) => {
+    for (const page of pageList) {
+      if (page.url && page.meta?.sitemap !== false) {
+        flattened.push(page);
+      }
+
+      if (page.pages) addPages(page.pages);
+      if (page.paginatedPages) addPages(page.paginatedPages);
+    }
+  };
+
+  addPages(pages);
+  return flattened;
+};
+
+const pageUrl = (siteUrl, page) => {
+  const baseUrl = siteUrl.replace(/\/$/, "");
+  return `${baseUrl}${page.url === "/" ? "/" : page.url}`;
+};
+
+const generateSitemapXml = (pages, siteUrl = "") => {
+  const seenUrls = new Set();
+  const urls = flattenPages(pages)
+    .filter((page) => {
+      if (seenUrls.has(page.url)) return false;
+      seenUrls.add(page.url);
+      return true;
+    })
+    .map((page) => {
+      const lastmod = formatSitemapDate(
+        page.updatedAtObj || page.dateObj || page.updated_at || new Date(),
+      );
+      const lastmodLine = lastmod ? `\n    <lastmod>${lastmod}</lastmod>` : "";
+
+      return `  <url>
+    <loc>${escapeXml(pageUrl(siteUrl, page))}</loc>${lastmodLine}
+  </url>`;
+    })
+    .join("\n");
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls}
+</urlset>
+`;
+};
+
+const generateRobotsTxt = (siteUrl = "") => {
+  const lines = ["User-agent: *", "Allow: /"];
+  if (siteUrl) {
+    lines.push(`Sitemap: ${siteUrl.replace(/\/$/, "")}/sitemap.xml`);
+  }
+  return `${lines.join("\n")}\n`;
+};
+
+const generateSeoFiles = async (pages, outputDir) => {
+  const siteUrl = defaultConfig.site_url || defaultConfig.url || "";
+  const sitemapXml = generateSitemapXml(pages, siteUrl);
+  const robotsTxt = generateRobotsTxt(siteUrl);
+
+  await fsExtra.ensureDir(outputDir);
+  await Promise.all([
+    fs.writeFile(path.join(outputDir, "sitemap.xml"), sitemapXml),
+    fs.writeFile(path.join(outputDir, "robots.txt"), robotsTxt),
+  ]);
+};
+
+export { flattenPages, generateRobotsTxt, generateSeoFiles, generateSitemapXml };

package/src/watcher.js

@@ -2,6 +2,7 @@ import chokidar from "chokidar";
 import livereload from "livereload";
 import path from "path";
 import fs from "fs";
+import { defaultConfig } from "./config.js";
 
 // Directory to extension mapping for filtering
 const dirExtensions = {
@@ -11,6 +12,7 @@ const dirExtensions = {
   css: [".css"],
   js: [".js"],
   partials: [".md", ".html"],
+  data: [".json", ".yaml", ".yml"],
 };
 
 // Build watch paths
@@ -74,6 +76,7 @@ function getChangeType(filePath) {
   if (topDir === "css") return "css";
   if (topDir === "js") return "js";
   if (topDir === "images") return "image";
+  if (topDir === "data") return "data";
   return "full"; // pages, layouts, partials, config files
 }
 
@@ -82,6 +85,7 @@ export default async function watch(outDir = "dist") {
   const { copySingleAsset, optimizeSingleImage } = await import("./assets.js");
   const { resetCaches } = await import("./layout.js");
   const { clearCache: clearPartialCache } = await import("./partials.js");
+  const { clearDataCache } = await import("./data.js");
   const watchPaths = getWatchPaths();
 
   if (watchPaths.length === 0) {
@@ -92,22 +96,25 @@ export default async function watch(outDir = "dist") {
   // Start livereload server
   const lrServer = livereload.createServer({
     usePolling: true,
-    delay: 100,
+    delay: defaultConfig.watcher_delay || 100,
   });
   const outPath = path.join(process.cwd(), outDir);
+  const livereloadPort = defaultConfig.livereload_port || 35729;
   lrServer.watch(outPath);
-  console.log("LiveReload server started on port 35729");
+  console.log(`LiveReload server started on port ${livereloadPort}`);
 
   // Initialize watcher (chokidar 4.x)
   // usePolling needed for network/cloud drives that don't emit native fs events
+  const watcherInterval = defaultConfig.watcher_interval || 500;
+  const watcherDelay = defaultConfig.watcher_delay || 100;
   const watcher = chokidar.watch(watchPaths, {
     persistent: true,
     ignoreInitial: true,
     usePolling: true,
-    interval: 500,
+    interval: watcherInterval,
     awaitWriteFinish: {
-      stabilityThreshold: 200,
-      pollInterval: 100,
+      stabilityThreshold: watcherDelay * 2,
+      pollInterval: watcherDelay,
     },
   });
 
@@ -123,25 +130,45 @@ export default async function watch(outDir = "dist") {
     try {
       if (event === "deleted") {
         // For deletions, do a full rebuild to clean up
-        console.log(`File deleted: ${filename}. Running full build...`);
+        console.log(`🗑️  File deleted: ${filename}. Running full build...`);
+        const rebuildStart = performance.now();
         clearPartialCache();
         await resetCaches();
         await build.default(outDir);
+        const rebuildTime = performance.now() - rebuildStart;
+        console.log(`   Rebuild completed in ${(rebuildTime / 1000).toFixed(2)}s`);
       } else if (changeType === "css" || changeType === "js") {
         // Full rebuild for CSS/JS to update cache-busting query strings in HTML
-        console.log(`Asset ${event}: ${filename}. Rebuilding...`);
+        console.log(`🎨 Asset ${event}: ${filename}. Rebuilding...`);
+        const rebuildStart = performance.now();
         await resetCaches();
         await build.default(outDir);
+        const rebuildTime = performance.now() - rebuildStart;
+        console.log(`   Rebuild completed in ${(rebuildTime / 1000).toFixed(2)}s`);
       } else if (changeType === "image") {
         // Incremental: just process the changed image
-        console.log(`Image ${event}: ${filename}`);
+        const imageStart = performance.now();
+        console.log(`🖼️  Image ${event}: ${filename}`);
         await optimizeSingleImage(filePath, outDir);
+        const imageTime = performance.now() - imageStart;
+        console.log(`   Optimized in ${(imageTime / 1000).toFixed(2)}s`);
+      } else if (changeType === "data") {
+        // Data file changed - clear data cache and rebuild
+        console.log(`📊 Data ${event}: ${filename}. Rebuilding...`);
+        const rebuildStart = performance.now();
+        clearDataCache();
+        await build.default(outDir);
+        const rebuildTime = performance.now() - rebuildStart;
+        console.log(`   Rebuild completed in ${(rebuildTime / 1000).toFixed(2)}s`);
       } else {
         // Full rebuild for pages, layouts, partials, config, and new CSS/JS files
-        console.log(`File ${event}: ${filename}. Running full build...`);
+        console.log(`📝 File ${event}: ${filename}. Running full build...`);
+        const rebuildStart = performance.now();
         clearPartialCache();
         await resetCaches();
         await build.default(outDir);
+        const rebuildTime = performance.now() - rebuildStart;
+        console.log(`   Rebuild completed in ${(rebuildTime / 1000).toFixed(2)}s`);
       }
       // Trigger browser refresh
       lrServer.refresh("/");