npm - @daz4126/swifty - Versions diffs - 2.10.0 → 2.12.0 - Mend

@daz4126/swifty 2.10.0 → 2.12.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/src/init.js CHANGED Viewed

@@ -2,62 +2,52 @@
 import fs from "fs";
 import path from "path";
-import { fileURLToPath } from "url";
-import { dirname } from "path";
-// Needed to emulate __dirname in ES modules
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-// Define the structure
-const structure = {
-  "pages/index.md": "This my home page.",
-  "layouts/": null,
-  "partials/": null,
-  "css/": null,
-  "js/": null,
-  "images/": null,
-  "config.yaml": `sitename: Swifty
+function getStructure(sitename) {
+  return {
+    "pages/index.md": `# Welcome to ${sitename}\n\nThis is my home page.`,
+    "layouts/": null,
+    "partials/": null,
+    "css/": null,
+    "js/": null,
+    "images/": null,
+    "data/": null,
+    "config.yaml": `sitename: ${sitename}
 breadcrumb_separator: "&raquo;"
 breadcrumb_class: swifty_breadcrumb
 link_class: swifty_link
-tag_class: tag
-default_layout_name: site
+tag_class: swifty_tag
+default_layout_name: default
 default_link_name: links
 max_image_size: 800
-dateFormat:
+dateFormat:
   weekday: short
   month: short
   day: numeric
   year: numeric`,
-  "template.html": `<!DOCTYPE html>
+    "template.html": `<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <link rel="icon" href="favicon.ico" sizes="48x48" type="image/x-icon">
-  <link rel="icon" href="favicon-16x16.png" sizes="16x16" type="image/x-icon">
-  <link rel="icon" href="favicon-32x32.png" sizes="32x32" type="image/png">
-  <link rel="apple-touch-icon" href="path/to/apple-touch-icon.png">
-  <link rel="icon" sizes="192x192" href="android-chrome-192x19.png">
-  <link rel="icon" sizes="512x512" href="android-chrome-512x512.png">
-  <title>{{ sitename }} || {{ title }}</title>
+  <title><%= sitename %> | <%= title %></title>
 </head>
 <body>
   <header>
-      <h1>Swifty</h1>
+      <h1>${sitename}</h1>
   </header>
     <main>
-    {{ content }}
+    <%= content %>
   </main>
     <footer>
     <p>This site was built with Swifty, the super speedy static site generator.</p>
   </footer>
 </body>
 </html>
-  `
-};
+  `,
+  };
+}
 function createStructure(basePath, structure) {
   Object.entries(structure).forEach(([filePath, content]) => {
@@ -71,7 +61,20 @@ function createStructure(basePath, structure) {
   });
 }
-const projectRoot = process.cwd();
-createStructure(projectRoot, structure);
+export default function init(sitename) {
+  const projectRoot = path.join(process.cwd(), sitename);
+  // Check if folder already exists
+  if (fs.existsSync(projectRoot)) {
+    console.error(`Error: Folder "${sitename}" already exists.`);
+    process.exit(1);
+  }
-console.log("✅ Swifty project initialized successfully!");
+  const structure = getStructure(sitename);
+  createStructure(projectRoot, structure);
+  console.log(`Site "${sitename}" created successfully!`);
+  console.log(`\nNext steps:`);
+  console.log(`  cd ${sitename}`);
+  console.log(`  npx swifty start`);
+}

package/src/layout.js CHANGED Viewed

@@ -40,7 +40,7 @@ const createTemplate = async () => {
     ? `<script type="module">import * as Turbo from 'https://esm.sh/@hotwired/turbo';</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
@@ -59,10 +59,10 @@ const createTemplate = async () => {
 };
 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 () => {

package/src/pages.js CHANGED Viewed

@@ -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,110 +63,183 @@ 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.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;
       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);
@@ -169,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);
   }
@@ -191,7 +266,7 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
         undefined,
         defaultConfig.dateFormat,
       ),
-      data: { ...config },
+      meta: { ...config },
       pages: [],
     };
@@ -205,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);
@@ -218,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 {
@@ -255,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);
@@ -263,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",
@@ -311,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(),
   );
 };