@daz4126/swifty 2.11.0 → 3.0.0

package/src/layout.js

@@ -7,6 +7,15 @@ import { getCssImports, getJsImports, getCssPreloads, getJsPreloads } from "./as
 const layoutCache = new Map();
 let template = null;
 
+const escapeAttr = (value) =>
+  String(value || "")
+    .replace(/&/g, "&")
+    .replace(/"/g, """)
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+
+const navigationEnabled = () => defaultConfig.morphing !== false;
+
 const getLayout = async (layoutName) => {
   if (!layoutName) return null;
   if (!layoutCache.has(layoutName)) {
@@ -30,17 +39,13 @@ const createTemplate = async () => {
   const preconnectHints = [
     '<link rel="preconnect" href="https://cdnjs.cloudflare.com" crossorigin>',
     '<link rel="dns-prefetch" href="https://cdnjs.cloudflare.com">',
-    ...(defaultConfig.turbo ? [
-      '<link rel="preconnect" href="https://esm.sh" crossorigin>',
-      '<link rel="dns-prefetch" href="https://esm.sh">',
-    ] : []),
   ].join('\n');
 
-  const turboScript = defaultConfig.turbo
-    ? `<script type="module">import * as Turbo from 'https://esm.sh/@hotwired/turbo';</script>`
+  const navigationScript = navigationEnabled()
+    ? `<script type="module" src="/swifty/swifty-navigation.js" data-swifty-navigation data-target="${escapeAttr(defaultConfig.morph_target || "main")}" data-prefetching="${defaultConfig.prefetching === false ? "off" : "intent"}" data-cache-size="${escapeAttr(defaultConfig.navigation_cache_size || 20)}" data-cache-ttl="${escapeAttr(defaultConfig.navigation_cache_ttl || 15)}"></script>`
     : '';
   const livereloadScript = process.env.SWIFTY_WATCH
-    ? `<script>document.write('<script src="http://' + (location.host || 'localhost').split(':')[0] + ':35729/livereload.js?snipver=1"></' + 'script>')</script>`
+    ? `<script>document.write('<script src="http://' + (location.host || 'localhost').split(':')[0] + ':${defaultConfig.livereload_port || 35729}/livereload.js?snipver=1"></' + 'script>')</script>`
     : '';
 
   // Preload local assets for faster loading
@@ -54,15 +59,15 @@ const createTemplate = async () => {
   const highlightCSS = `<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/styles/monokai-sublime.min.css">`;
 
   // Order: preconnect hints -> preloads -> actual assets -> scripts
-  const template = templateContent.replace('</head>', `${preconnectHints}\n${preloads}\n${turboScript}\n${highlightCSS}\n${imports}\n${livereloadScript}\n</head>`);
+  const template = templateContent.replace('</head>', `${preconnectHints}\n${preloads}\n${navigationScript}\n${highlightCSS}\n${imports}\n${livereloadScript}\n</head>`);
   return template;
 };
 
 const applyLayoutAndWrapContent = async (page,content) => {
-    const layoutContent = await getLayout(page.data.layout !== undefined ? page.data.layout : page.layout);
+    const layoutContent = await getLayout(page.meta.layout !== undefined ? page.meta.layout : page.layout);
     if (!layoutContent) return content;
     // Use function to avoid $` special replacement patterns in content
-    return layoutContent.replace(/\{\{\s*content\s*\}\}/g, () => content);
+    return layoutContent.replace(/<%=\s*content\s*%>/g, () => content);
   };
 
 const getTemplate = async () => {
@@ -77,4 +82,4 @@ const resetCaches = async () => {
   template = await createTemplate();
 };
 
-export { getLayout, applyLayoutAndWrapContent, getTemplate, resetCaches };
+export { getLayout, applyLayoutAndWrapContent, getTemplate, resetCaches };

package/src/pages.js

@@ -2,11 +2,13 @@
 import { replacePlaceholders } from "./partials.js";
 import { dirs, defaultConfig, loadConfig } from "./config.js";
 import { getTemplate, applyLayoutAndWrapContent } from "./layout.js";
+import { chunkPages, generatePaginationNav } from "./pagination.js";
 import { marked } from "marked";
 import matter from "gray-matter";
 import fs from "fs/promises";
 import fsExtra from "fs-extra";
 import path from "path";
+import { mapLimit } from "./concurrency.js";
 
 // Returns stats if valid (directory or .md file), null otherwise
 const getValidStats = async (filePath) => {
@@ -42,6 +44,9 @@ const parseDate = (dateValue) => {
 const tagsMap = new Map();
 const pageIndex = [];
 const pageIndexUrls = new Set();
+const partialExtensions = [".md", ".html"];
+
+const getBuildConcurrency = () => defaultConfig.build_concurrency || 16;
 
 const addToTagMap = (tag, page) => {
   if (!tagsMap.has(tag)) tagsMap.set(tag, []);
@@ -58,93 +63,102 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
 
   const pages = [];
   const folderConfig = await loadConfig(sourceDir);
-  const config = { ...defaultConfig, ...parent?.data, ...folderConfig };
+  const config = { ...defaultConfig, ...parent?.meta, ...folderConfig };
   const { dateFormat } = config;
 
   try {
     const files = await fs.readdir(sourceDir, { withFileTypes: true });
 
-    // Collect promises for processing all files
-    const filePromises = files.map(async (file) => {
-      const filePath = path.join(sourceDir, file.name);
-      const stats = await getValidStats(filePath);
-      if (!stats) return null;
-
-      const root = file.name === "index.md" && !parent;
-      const relativePath = path.relative(baseDir, filePath).replace(/\\/g, "/");
-      const finalPath = `/${relativePath.replace(/\.md$/, "")}`;
-      const name = root
-        ? "Home"
-        : capitalize(file.name.replace(/\.md$/, "").replace(/-/g, " "));
-      const isDirectory = stats.isDirectory();
-      const layoutFileExists =
-        parent &&
-        (await fsExtra.pathExists(`${dirs.layouts}/${parent.filename}.html`));
-      const layout = layoutFileExists
-        ? parent.filename
-        : parent
-          ? parent.layout
-          : config.default_layout_name;
-
-      const page = {
-        name,
-        root,
-        layout,
-        filePath,
-        filename: file.name.replace(/\.md$/, ""),
-        url: root ? "/" : finalPath,
-        nav: !parent && !root,
-        parent: parent
-          ? { title: parent.data.title, url: parent.url }
-          : undefined,
-        folder: isDirectory,
-        title: name,
-        created_at: new Date(stats.birthtime).toLocaleDateString(
-          undefined,
-          dateFormat,
-        ),
-        updated_at: new Date(stats.mtime).toLocaleDateString(
-          undefined,
-          dateFormat,
-        ),
-        date: new Date(stats.birthtime).toLocaleDateString(
-          undefined,
-          dateFormat,
-        ),
-        data: root ? { ...defaultConfig } : { ...config },
-      };
+    const fileResults = await mapLimit(
+      files,
+      async (file) => {
+        const filePath = path.join(sourceDir, file.name);
+        const stats = await getValidStats(filePath);
+        if (!stats) return null;
+
+        const root = file.name === "index.md" && !parent;
+        const relativePath = path.relative(baseDir, filePath).replace(/\\/g, "/");
+        const finalPath = `/${relativePath.replace(/\.md$/, "")}`;
+        const name = root
+          ? "Home"
+          : capitalize(file.name.replace(/\.md$/, "").replace(/-/g, " "));
+        const isDirectory = stats.isDirectory();
+        const layoutFileExists =
+          parent &&
+          (await fsExtra.pathExists(`${dirs.layouts}/${parent.filename}.html`));
+        const layout = layoutFileExists
+          ? parent.filename
+          : parent
+            ? parent.layout
+            : config.default_layout_name;
+
+        const page = {
+          name,
+          root,
+          layout,
+          filePath,
+          filename: file.name.replace(/\.md$/, ""),
+          url: root ? "/" : finalPath,
+          nav: !parent && !root,
+          parent: parent
+            ? { title: parent.meta.title, url: parent.url }
+            : undefined,
+          folder: isDirectory,
+          title: name,
+          createdAtObj: stats.birthtime,
+          updatedAtObj: stats.mtime,
+          created_at: new Date(stats.birthtime).toLocaleDateString(
+            undefined,
+            dateFormat,
+          ),
+          updated_at: new Date(stats.mtime).toLocaleDateString(
+            undefined,
+            dateFormat,
+          ),
+          date: new Date(stats.birthtime).toLocaleDateString(
+            undefined,
+            dateFormat,
+          ),
+          meta: root ? { ...defaultConfig } : { ...config },
+        };
+
+        if (path.extname(file.name) === ".md") {
+          const markdownContent = await fs.readFile(filePath, "utf-8");
+          const { data, content } = matter(markdownContent);
+          Object.assign(page, { meta: { ...page.meta, ...data }, content });
+          page.title = page.meta.title || page.title;
+          page.name = page.meta.title || page.name;
+
+          // Allow front matter to override nav (opt in or opt out)
+          if (typeof data.nav === "boolean") {
+            page.nav = data.nav;
+          }
 
-      if (path.extname(file.name) === ".md") {
-        const markdownContent = await fs.readFile(filePath, "utf-8");
-        const { data, content } = matter(markdownContent);
-        Object.assign(page, { data: { ...page.data, ...data }, content });
-
-        // If front matter has a date, parse and format it
-        if (data.date) {
-          const parsedDate = parseDate(data.date);
-          if (parsedDate) {
-            page.dateObj = parsedDate;
-            page.date = parsedDate.toLocaleDateString(undefined, dateFormat);
-            page.data.date = page.date;
+          // If front matter has a date, parse and format it
+          if (data.date) {
+            const parsedDate = parseDate(data.date);
+            if (parsedDate) {
+              page.dateObj = parsedDate;
+              page.date = parsedDate.toLocaleDateString(undefined, dateFormat);
+              page.meta.date = page.date;
+            }
           }
         }
-      }
-
-      // For directories, we defer recursion separately
-      return { page, isDirectory };
-    });
 
-    // Await all file processing
-    const fileResults = await Promise.all(filePromises);
+        // For directories, we defer recursion separately
+        return { page, isDirectory };
+      },
+      getBuildConcurrency(),
+    );
 
     // Now handle directories recursively
-    const directoryPromises = fileResults.map(async (result) => {
+    await mapLimit(fileResults, async (result) => {
       if (!result) return;
 
       const { page, isDirectory } = result;
 
       // Skip draft pages in production builds
-      if (page.data.draft && !process.env.SWIFTY_WATCH) return;
+      if (page.meta.draft && !process.env.SWIFTY_WATCH) return;
 
       // Skip scheduled pages (future date) in production builds
       if (page.dateObj && page.dateObj > new Date() && !process.env.SWIFTY_WATCH) return;
@@ -152,22 +166,80 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
       if (isDirectory) {
         page.pages = await generatePages(page.filePath, baseDir, page);
 
+        // Load folder's own config for pagination settings
+        const dirConfig = await loadConfig(page.filePath);
+        const mergedConfig = { 
+          ...page.meta, 
+          ...dirConfig,
+          // Only set default page_count if explicitly specified in either page meta or dir config
+          page_count: dirConfig.page_count || page.meta.page_count
+        };
+        page.meta = mergedConfig;
+
         page.pages.sort((a, b) => {
-          if (a.data.position && b.data.position) {
-            return a.data.position - b.data.position;
+          if (a.meta.position && b.meta.position) {
+            return a.meta.position - b.meta.position;
           }
           const dateA = a.dateObj || new Date(a.created_at);
           const dateB = b.dateObj || new Date(b.created_at);
-          const sortOrder = (config.date_sort_order || "desc").toLowerCase();
+          const sortOrder = (mergedConfig.date_sort_order || "desc").toLowerCase();
           return sortOrder === "asc" ? dateA - dateB : dateB - dateA;
         });
 
-        page.content = await generateLinkList(page.filename, page.pages);
+        // Handle pagination if page_count is set
+        const pageCount = mergedConfig.page_count;
+        if (pageCount && page.pages.length > pageCount) {
+          page.allPages = page.pages;
+          const chunks = chunkPages(page.pages, pageCount);
+          const totalPages = chunks.length;
+          const baseUrl = `${page.url}/`;
+
+          // Store visible pages for first page (used by links_to_children)
+          page.visiblePages = chunks[0];
+
+          // First page content
+          page.content = await generateLinkList(page.filename, chunks[0]);
+          page.meta.pagination = generatePaginationNav({
+            currentPage: 1,
+            totalPages,
+            baseUrl,
+            config: page.meta,
+          });
+
+          // Create pagination pages for page 2, 3, etc.
+          page.paginatedPages = [];
+          for (let i = 1; i < chunks.length; i++) {
+            const pageNum = i + 1;
+            const paginatedPage = {
+              name: `${page.name} - Page ${pageNum}`,
+              title: `${page.meta.title || page.name} - Page ${pageNum}`,
+              url: `${page.url}/page/${pageNum}`,
+              folder: false,
+              layout: page.layout,
+              parent: { title: page.meta.title || page.name, url: page.url },
+              meta: {
+                ...page.meta,
+                title: `${page.meta.title || page.name} - Page ${pageNum}`,
+                pagination: generatePaginationNav({
+                  currentPage: pageNum,
+                  totalPages,
+                  baseUrl,
+                  config: page.meta,
+                }),
+              },
+              content: await generateLinkList(page.filename, chunks[i]),
+            };
+            page.paginatedPages.push(paginatedPage);
+          }
+        } else {
+          page.content = await generateLinkList(page.filename, page.pages);
+          page.meta.pagination = '';
+        }
       }
 
       // Add tags
-      if (page.data.tags) {
-        page.data.tags.forEach((tag) => addToTagMap(tag, page));
+      if (page.meta.tags) {
+        page.meta.tags.forEach((tag) => addToTagMap(tag, page));
       }
 
       pages.push(page);
@@ -175,10 +247,7 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
         pageIndexUrls.add(page.url);
         pageIndex.push({ url: page.url, title: page.title, nav: page.nav });
       }
-    });
-
-    // Await all directory recursion
-    await Promise.all(directoryPromises);
+    }, getBuildConcurrency());
   } catch (err) {
     console.error("Error reading directory:", err);
   }
@@ -197,7 +266,7 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
         undefined,
         defaultConfig.dateFormat,
       ),
-      data: { ...config },
+      meta: { ...config },
       pages: [],
     };
 
@@ -211,7 +280,7 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
         ),
         url: `/tags/${tag}`,
         layout: tagLayout ? "tags" : defaultConfig.default_layout_name,
-        data: { ...config, title: `Pages tagged with ${capitalize(tag)}` },
+        meta: { ...config, title: `Pages tagged with ${capitalize(tag)}` },
       };
       page.content = await generateLinkList("tags", pagesForTag);
 
@@ -224,24 +293,25 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
 };
 
 const generateLinkList = async (name, pages) => {
-  const partialFile = `${name}.md`;
-  const partialPath = path.join(dirs.partials, partialFile);
-  const linksPath = path.join(
-    dirs.partials,
+  const findPartialPath = async (partialName) => {
+    for (const ext of partialExtensions) {
+      const partialPath = path.join(dirs.partials, `${partialName}${ext}`);
+      if (await fsExtra.pathExists(partialPath)) return partialPath;
+    }
+    return null;
+  };
+
+  const partialPath = await findPartialPath(name);
+  const defaultPath = await findPartialPath(
     defaultConfig.default_link_name || "links",
   );
-  // Check if either file exists in the 'partials' folder (in parallel)
-  const [fileExists, defaultExists] = await Promise.all([
-    fsExtra.pathExists(partialPath),
-    fsExtra.pathExists(linksPath),
-  ]);
-  if (fileExists || defaultExists) {
-    const partialContent = await fs.readFile(
-      fileExists ? partialPath : linksPath,
-      "utf-8",
-    );
-    const content = await Promise.all(
-      pages.map((page) => replacePlaceholders(partialContent, page)),
+
+  if (partialPath || defaultPath) {
+    const partialContent = await fs.readFile(partialPath || defaultPath, "utf-8");
+    const content = await mapLimit(
+      pages,
+      (page) => replacePlaceholders(partialContent, page),
+      getBuildConcurrency(),
     );
     return content.join("\n");
   } else {
@@ -261,7 +331,7 @@ const render = async (page) => {
   // Use function to avoid $` special replacement patterns in content
   const template = await getTemplate();
   const htmlWithTemplate = template.replace(
-    /\{\{\s*content\s*\}\}/g,
+    /<%=\s*content\s*%>/g,
     () => wrappedContent,
   );
   const finalContent = await replacePlaceholders(htmlWithTemplate, page);
@@ -269,45 +339,78 @@ const render = async (page) => {
 };
 
 const createPages = async (pages, distDir = dirs.dist) => {
-  await Promise.all(
-    pages.map(async (page) => {
+  await mapLimit(
+    pages,
+    async (page) => {
       const html = await render(page);
       const pageDir = path.join(distDir, page.url);
       const pagePath = path.join(distDir, page.url, "index.html");
       await fsExtra.ensureDir(pageDir);
       await fs.writeFile(pagePath, html);
       if (page.folder) {
-        await createPages(page.pages, distDir); // Recursive still needs to await
+        await createPages(page.pages, distDir);
+        // Write pagination pages if they exist
+        if (page.paginatedPages?.length) {
+          await createPages(page.paginatedPages, distDir);
+        }
       }
-    }),
+    },
+    getBuildConcurrency(),
   );
 };
 
 const addLinks = async (pages, parent) => {
-  await Promise.all(
-    pages.map(async (page) => {
-      page.data ||= {};
-      page.data.links_to_tags = page?.data?.tags?.length
-        ? page.data.tags
+  // Filter out folders and index pages for prev/next calculation (only content pages)
+  const contentPages = pages.filter((p) => !p.folder && p.filename !== 'index');
+
+  await mapLimit(
+    pages,
+    async (page) => {
+      page.meta ||= {};
+      page.meta.links_to_tags = page?.meta?.tags?.length
+        ? page.meta.tags
             .map(
               (tag) =>
                 `<a class="${defaultConfig.tag_class}" href="/tags/${tag}">${tag}</a>`,
             )
             .join("")
         : "";
+      const crumbTitle = page.meta.title || page.title || page.name;
       const crumb = page.root
         ? ""
-        : ` ${defaultConfig.breadcrumb_separator} <a class="${defaultConfig.breadcrumb_class}" href="${page.url}">${page.name}</a>`;
-      page.data.breadcrumbs = parent
-        ? parent.data.breadcrumbs + crumb
+        : ` ${defaultConfig.breadcrumb_separator} <a class="${defaultConfig.breadcrumb_class}" href="${page.url}">${crumbTitle}</a>`;
+      page.meta.breadcrumbs = parent
+        ? parent.meta.breadcrumbs + crumb
         : `<a class="${defaultConfig.breadcrumb_class}" href="/">Home</a>` +
           crumb;
 
+      // Generate prev/next links based on sibling position (only for content pages, not folders or index)
+      const linkClass = defaultConfig.prev_next_class || defaultConfig.link_class || '';
+      const classAttr = linkClass ? ` class="${linkClass}"` : '';
+
+      if (!page.folder && page.filename !== 'index') {
+        const pageIndex = contentPages.indexOf(page);
+        const prevSibling = pageIndex > 0 ? contentPages[pageIndex - 1] : null;
+        const nextSibling = pageIndex < contentPages.length - 1 ? contentPages[pageIndex + 1] : null;
+
+        page.meta.prev_page = prevSibling
+          ? `<a href="${prevSibling.url}"${classAttr}>${prevSibling.title || prevSibling.name}</a>`
+          : '';
+        page.meta.next_page = nextSibling
+          ? `<a href="${nextSibling.url}"${classAttr}>${nextSibling.title || nextSibling.name}</a>`
+          : '';
+      } else {
+        page.meta.prev_page = '';
+        page.meta.next_page = '';
+      }
+
       // Run independent link generation in parallel
+      // Use visiblePages for paginated folders (first page only shows its chunk)
+      const childPages = page.visiblePages || page.pages;
       const [links_to_children, links_to_siblings, links_to_self_and_siblings, nav_links] =
         await Promise.all([
-          page.pages
-            ? generateLinkList(page.filename, page.pages)
+          childPages
+            ? generateLinkList(page.filename, childPages)
             : Promise.resolve(""),
           generateLinkList(
             page.parent?.filename || "pages",
@@ -317,15 +420,24 @@ const addLinks = async (pages, parent) => {
           generateLinkList("nav", pageIndex.filter((p) => p.nav)),
         ]);
 
-      page.data.links_to_children = links_to_children;
-      page.data.links_to_siblings = links_to_siblings;
-      page.data.links_to_self_and_siblings = links_to_self_and_siblings;
-      page.data.nav_links = nav_links;
+      page.meta.links_to_children = links_to_children;
+      page.meta.links_to_siblings = links_to_siblings;
+      page.meta.links_to_self_and_siblings = links_to_self_and_siblings;
+      page.meta.nav_links = nav_links;
 
       if (page.pages) {
         await addLinks(page.pages, page);
       }
-    }),
+
+      // Process pagination pages - inherit breadcrumbs and nav_links
+      if (page.paginatedPages) {
+        for (const pp of page.paginatedPages) {
+          pp.meta.breadcrumbs = page.meta.breadcrumbs;
+          pp.meta.nav_links = nav_links;
+        }
+      }
+    },
+    getBuildConcurrency(),
   );
 };
 

package/src/pagination.js

@@ -0,0 +1,58 @@
+// pagination.js
+
+/**
+ * Split array into chunks of specified size
+ * @param {Array} items - Items to paginate
+ * @param {number} pageSize - Items per page
+ * @returns {Array[]} - Array of page chunks
+ */
+export const chunkPages = (items, pageSize) => {
+  const chunks = [];
+  for (let i = 0; i < items.length; i += pageSize) {
+    chunks.push(items.slice(i, i + pageSize));
+  }
+  return chunks;
+};
+
+/**
+ * Generate pagination navigation HTML
+ * @param {object} options - Pagination options
+ * @param {number} options.currentPage - Current page number (1-indexed)
+ * @param {number} options.totalPages - Total number of pages
+ * @param {string} options.baseUrl - Base URL for the paginated folder (with trailing slash)
+ * @param {object} options.config - Config with CSS class names
+ * @returns {string} - HTML for pagination navigation
+ */
+export const generatePaginationNav = ({ currentPage, totalPages, baseUrl, config = {} }) => {
+  if (totalPages <= 1) return '';
+
+  const paginationClass = config.pagination_class || 'swifty_pagination';
+  const linkClass = config.pagination_link_class || 'swifty_pagination_link';
+  const currentClass = config.pagination_current_class || 'swifty_pagination_current';
+
+  const links = [];
+
+  // Previous link
+  if (currentPage > 1) {
+    const prevUrl = currentPage === 2 ? baseUrl : `${baseUrl}page/${currentPage - 1}/`;
+    links.push(`<a href="${prevUrl}" class="${linkClass} swifty_pagination_prev">&laquo; Previous</a>`);
+  }
+
+  // Page numbers
+  for (let i = 1; i <= totalPages; i++) {
+    const pageUrl = i === 1 ? baseUrl : `${baseUrl}page/${i}/`;
+    if (i === currentPage) {
+      links.push(`<span class="${currentClass}">${i}</span>`);
+    } else {
+      links.push(`<a href="${pageUrl}" class="${linkClass}">${i}</a>`);
+    }
+  }
+
+  // Next link
+  if (currentPage < totalPages) {
+    const nextUrl = `${baseUrl}page/${currentPage + 1}/`;
+    links.push(`<a href="${nextUrl}" class="${linkClass} swifty_pagination_next">Next &raquo;</a>`);
+  }
+
+  return `<nav class="${paginationClass}">${links.join(' ')}</nav>`;
+};