@daz4126/swifty 3.2.0 → 4.1.0

package/src/index.js

@@ -1,3 +1,10 @@
 export { default, default as build, prepareOutputDirectory } from "./build.js";
 export { defaultConfig, loadConfig, reloadConfig } from "./config.js";
 export { addLinks, createPages, generatePages } from "./pages.js";
+export { startServer } from "./server.js";
+export {
+  applyBasePathToHtml,
+  normalizeBasePath,
+  normalizePermalink,
+  withBasePath,
+} from "./urls.js";

package/src/init.js

@@ -12,7 +12,11 @@ function getStructure(sitename) {
     "js/": null,
     "images/": null,
     "data/": null,
+    "public/": null,
+    ".gitignore": `node_modules/
+.swifty-cache/`,
     "config.yaml": `sitename: ${sitename}
+base_path: ""
 breadcrumb_separator: "»"
 breadcrumb_class: swifty_breadcrumb
 link_class: swifty_link

package/src/layout.js

@@ -37,7 +37,14 @@ const getLayout = async (layoutName) => {
 const createTemplate = async () => {
   // Read the template from pages folder
   const templatePath = path.join(baseDir, 'template.html');
-  const templateContent = await fs.readFile(templatePath, 'utf-8');
+  let templateContent;
+  try {
+    templateContent = await fs.readFile(templatePath, 'utf-8');
+  } catch (error) {
+    throw new Error(`Unable to read template ${templatePath}: ${error.message}`, {
+      cause: error,
+    });
+  }
 
   // Preconnect hints for external CDNs (improves connection setup time)
   const preconnectHints = [

package/src/minify.js

@@ -1,138 +1,44 @@
-let protectionSequence = 0;
-
-const protectBlocks = (content, pattern) => {
-  const blocks = [];
-  const tokenPrefix = `__SWIFTY_MINIFY_BLOCK_${protectionSequence++}_`;
-  const protectedContent = content.replace(pattern, (match) => {
-    const token = `${tokenPrefix}${blocks.length}__`;
-    blocks.push(match);
-    return token;
-  });
-
-  return {
-    content: protectedContent,
-    restore: (value) =>
-      value.replace(
-        new RegExp(`${tokenPrefix}(\\d+)__`, "g"),
-        (_, index) => blocks[index],
-      ),
-  };
-};
-
-const protectCssValues = (css) => {
-  const blocks = [];
-  let content = "";
-
-  const protect = (start, end) => {
-    const token = `__SWIFTY_MINIFY_BLOCK_${blocks.length}__`;
-    blocks.push(css.slice(start, end));
-    content += token;
-    return end;
-  };
-
-  const readStringEnd = (start) => {
-    const quote = css[start];
-    let index = start + 1;
-
-    while (index < css.length) {
-      if (css[index] === "\\") {
-        index += 2;
-        continue;
-      }
-      if (css[index] === quote) return index + 1;
-      index += 1;
-    }
-
-    return css.length;
-  };
-
-  const readUrlEnd = (start) => {
-    let index = start + 4;
-
-    while (index < css.length) {
-      const char = css[index];
-      if (char === "\"" || char === "'") {
-        index = readStringEnd(index);
-        continue;
-      }
-      if (char === "\\") {
-        index += 2;
-        continue;
-      }
-      if (char === ")") return index + 1;
-      index += 1;
-    }
-
-    return css.length;
-  };
-
-  for (let index = 0; index < css.length; ) {
-    const char = css[index];
-    const isUrl = css.slice(index, index + 4).toLowerCase() === "url(";
-
-    if (char === "/" && css[index + 1] === "*") {
-      const commentEnd = css.indexOf("*/", index + 2);
-      const end = commentEnd === -1 ? css.length : commentEnd + 2;
-      content += css.slice(index, end);
-      index = end;
-    } else if (char === "\"" || char === "'") {
-      index = protect(index, readStringEnd(index));
-    } else if (isUrl) {
-      index = protect(index, readUrlEnd(index));
-    } else {
-      content += char;
-      index += 1;
-    }
-  }
-
-  return {
-    content,
-    restore: (value) =>
-      value.replace(/__SWIFTY_MINIFY_BLOCK_(\d+)__/g, (_, index) => blocks[index]),
-  };
-};
+import CleanCSS from "clean-css";
+import { minify as minifyHtmlContent } from "html-minifier-terser";
+import { minify as minifyJsContent } from "terser";
 
 const minifyCss = (css) => {
-  const values = protectCssValues(css);
+  const result = new CleanCSS({
+    level: 1,
+    rebase: false,
+  }).minify(css);
 
-  const minified = values.content
-    .replace(/\/\*[\s\S]*?\*\//g, "")
-    .replace(/\s+/g, " ")
-    .replace(/\s*([{}:;,])\s*/g, "$1")
-    .replace(/;}/g, "}")
-    .trim();
+  if (result.errors.length) {
+    throw new Error(result.errors.join("; "));
+  }
 
-  return values.restore(minified);
+  return result.styles;
 };
 
-const minifyJs = (js) => {
-  const strings = protectBlocks(js, /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/g);
-
-  const minified = strings.content
-    .split("\n")
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .join("\n");
+const minifyJs = async (js) => {
+  const result = await minifyJsContent(js, {
+    compress: true,
+    mangle: false,
+    format: {
+      comments: /^!/,
+    },
+  });
 
-  return strings.restore(minified);
+  return result.code || "";
 };
 
-const minifyHtml = (html) => {
-  const blocks = protectBlocks(
-    html,
-    /<(pre|code|textarea|script|style)\b[^>]*>[\s\S]*?<\/\1>/gi,
-  );
-  const strings = protectBlocks(
-    blocks.content,
-    /(["'])(?:\\[\s\S]|(?!\1)[^\\])*\1/g,
-  );
-
-  const minified = strings.content
-    .replace(/<!--(?!\[if|<!|>)[\s\S]*?-->/g, "")
-    .replace(/\s+/g, " ")
-    .trim();
-
-  return blocks.restore(strings.restore(minified));
-};
+const minifyHtml = (html) =>
+  minifyHtmlContent(html, {
+    caseSensitive: true,
+    collapseWhitespace: true,
+    conservativeCollapse: true,
+    continueOnParseError: false,
+    keepClosingSlash: true,
+    minifyCSS: false,
+    minifyJS: false,
+    removeComments: true,
+    removeScriptTypeAttributes: true,
+    removeStyleLinkTypeAttributes: true,
+  });
 
 export { minifyCss, minifyHtml, minifyJs };

package/src/pages.js

@@ -3,7 +3,6 @@ import fs from "fs/promises";
 import path from "path";
 
 import fsExtra from "fs-extra";
-import matter from "gray-matter";
 
 import { replacePlaceholders } from "./partials.js";
 import { dirs, defaultConfig, loadConfig } from "./config.js";
@@ -12,6 +11,13 @@ import { chunkPages, generatePaginationNav } from "./pagination.js";
 import { marked } from "./markdown.js";
 import { mapLimit } from "./concurrency.js";
 import { minifyHtml } from "./minify.js";
+import { parseFrontMatter } from "./frontmatter.js";
+import {
+  applyBasePathToHtml,
+  normalizePermalink,
+  routeToOutputPath,
+  withBasePath,
+} from "./urls.js";
 
 // Returns stats if valid (directory or .md file), null otherwise
 const getValidStats = async (filePath) => {
@@ -49,10 +55,23 @@ const applyMarkdownFileToPage = async (
   filePath,
   { notFound = false, folderIndex = false } = {},
 ) => {
-  const markdownContent = await fs.readFile(filePath, "utf-8");
-  const { data, content } = matter(markdownContent);
+  let parsed;
+  try {
+    const markdownContent = await fs.readFile(filePath, "utf-8");
+    parsed = parseFrontMatter(markdownContent);
+  } catch (error) {
+    throw new Error(`Unable to parse Markdown file ${filePath}: ${error.message}`, {
+      cause: error,
+    });
+  }
+  const { data, content } = parsed;
   Object.assign(page, { meta: { ...page.meta, ...data }, content });
 
+  if (data.permalink !== undefined) {
+    page.route = normalizePermalink(data.permalink);
+    page.url = withBasePath(page.route);
+  }
+
   if (folderIndex) {
     const stats = await fs.stat(filePath);
     const { dateFormat } = page.meta;
@@ -148,13 +167,15 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
             ? parent.layout
             : config.default_layout_name;
 
+        const route = root ? "/" : finalPath;
         const page = {
           name,
           root,
           layout,
           filePath,
           filename: file.name.replace(/\.md$/, ""),
-          url: root ? "/" : finalPath,
+          route,
+          url: withBasePath(route),
           nav: !parent && !root && !notFound,
           parent: parent
             ? { title: parent.meta.title, url: parent.url }
@@ -211,11 +232,11 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
 
         // Load folder's own config for pagination settings
         const dirConfig = await loadConfig(page.filePath);
-        const mergedConfig = { 
-          ...page.meta, 
+        const mergedConfig = {
           ...dirConfig,
+          ...page.meta,
           // 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_count: page.meta.page_count ?? dirConfig.page_count,
         };
         page.meta = mergedConfig;
 
@@ -258,6 +279,7 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
             const paginatedPage = {
               name: `${page.name} - Page ${pageNum}`,
               title: `${page.meta.title || page.name} - Page ${pageNum}`,
+              route: `${page.route}/page/${pageNum}`,
               url: `${page.url}/page/${pageNum}`,
               folder: false,
               layout: page.layout,
@@ -295,15 +317,18 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
         pageIndex.push({ url: page.url, title: page.title, nav: page.nav });
       }
     }, getBuildConcurrency());
-  } catch (err) {
-    console.error("Error reading directory:", err);
+  } catch (error) {
+    throw new Error(`Unable to generate pages from ${sourceDir}: ${error.message}`, {
+      cause: error,
+    });
   }
 
   // Make Tags page
   if (!parent && tagsMap.size) {
     const tagLayout = await fsExtra.pathExists(`${dirs.layouts}/tags.html`);
     const tagPage = {
-      url: "/tags",
+      route: "/tags",
+      url: withBasePath("/tags"),
       nav: false,
       folder: true,
       name: "Tags",
@@ -318,6 +343,7 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
     };
 
     for (const [tag, pagesForTag] of tagsMap) {
+      const route = `/tags/${tag}`;
       const page = {
         name: tag,
         title: tag,
@@ -325,7 +351,8 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
           undefined,
           defaultConfig.dateFormat,
         ),
-        url: `/tags/${tag}`,
+        route,
+        url: withBasePath(route),
         layout: tagLayout ? "tags" : defaultConfig.default_layout_name,
         meta: { ...config, title: `Pages tagged with ${capitalize(tag)}` },
       };
@@ -372,17 +399,23 @@ const generateLinkList = async (name, pages) => {
 };
 
 const render = async (page) => {
-  const replacedContent = await replacePlaceholders(page.content, page);
-  const htmlContent = marked.parse(replacedContent); // Markdown processed once
-  const wrappedContent = await applyLayoutAndWrapContent(page, htmlContent);
-  // Use function to avoid $` special replacement patterns in content
-  const template = await getTemplate();
-  const htmlWithTemplate = template.replace(
-    /<%=\s*content\s*%>/g,
-    () => wrappedContent,
-  );
-  const finalContent = await replacePlaceholders(htmlWithTemplate, page);
-  return finalContent;
+  try {
+    const replacedContent = await replacePlaceholders(page.content, page);
+    const htmlContent = marked.parse(replacedContent); // Markdown processed once
+    const wrappedContent = await applyLayoutAndWrapContent(page, htmlContent);
+    // Use function to avoid $` special replacement patterns in content
+    const template = await getTemplate();
+    const htmlWithTemplate = template.replace(
+      /<%=\s*content\s*%>/g,
+      () => wrappedContent,
+    );
+    const finalContent = await replacePlaceholders(htmlWithTemplate, page);
+    return applyBasePathToHtml(finalContent);
+  } catch (error) {
+    throw new Error(`Unable to render page ${page.url}: ${error.message}`, {
+      cause: error,
+    });
+  }
 };
 
 const createPages = async (pages, distDir = dirs.dist) => {
@@ -390,12 +423,20 @@ const createPages = async (pages, distDir = dirs.dist) => {
     pages,
     async (page) => {
       const renderedHtml = await render(page);
-      const html = minificationEnabled() ? minifyHtml(renderedHtml) : renderedHtml;
-      const pageDir = page.notFound ? distDir : path.join(distDir, page.url);
+      let html = renderedHtml;
+      if (minificationEnabled()) {
+        try {
+          html = await minifyHtml(renderedHtml);
+        } catch (error) {
+          throw new Error(`Unable to minify HTML for ${page.url}: ${error.message}`, {
+            cause: error,
+          });
+        }
+      }
       const pagePath = page.notFound
         ? path.join(distDir, "404.html")
-        : path.join(distDir, page.url, "index.html");
-      await fsExtra.ensureDir(pageDir);
+        : path.join(distDir, routeToOutputPath(page.route || page.url));
+      await fsExtra.ensureDir(path.dirname(pagePath));
       await fs.writeFile(pagePath, html);
       if (page.folder) {
         await createPages(page.pages, distDir);
@@ -422,7 +463,7 @@ const addLinks = async (pages, parent) => {
         ? page.meta.tags
             .map(
               (tag) =>
-                `<a class="${defaultConfig.tag_class}" href="/tags/${tag}">${tag}</a>`,
+                `<a class="${defaultConfig.tag_class}" href="${withBasePath(`/tags/${tag}`)}">${tag}</a>`,
             )
             .join("")
         : "";
@@ -432,7 +473,7 @@ const addLinks = async (pages, parent) => {
         : ` ${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>` +
+        : `<a class="${defaultConfig.breadcrumb_class}" href="${withBasePath("/")}">Home</a>` +
           crumb;
 
       // Generate prev/next links based on sibling position (only for content pages, not folders or index)

package/src/partials.js

@@ -8,6 +8,7 @@ import { dirs, defaultConfig } from "./config.js";
 import { marked } from "./markdown.js";
 import { loadData } from "./data.js";
 import { getResponsiveImage } from "./assets.js";
+import { withBasePath, withoutBasePath } from "./urls.js";
 
 const partialCache = new Map();
 const imageExtensionRegex = /\.(png|jpe?g|webp)(?=([?#]|$))/i;
@@ -130,8 +131,7 @@ const loadPartialData = async (partialName) => {
     return partialData;
   }
 
-  console.warn(`Include "${partialName}" not found.`);
-  return { content: `<p>Include "${partialName}" not found.</p>`, raw: true };
+  throw new Error(`Partial "${partialName}" was not found in ${dirs.partials}`);
 };
 
 const loadPartial = async (partialName) => {
@@ -140,13 +140,14 @@ const loadPartial = async (partialName) => {
 };
 
 const shouldRewriteImageUrl = (url) => {
-  if (!url || !url.startsWith("/images/")) return false;
-  return imageExtensionRegex.test(url);
+  const route = withoutBasePath(url);
+  if (!route || !route.startsWith("/images/")) return false;
+  return imageExtensionRegex.test(route);
 };
 
 const rewriteImageUrl = (url) => {
   if (!shouldRewriteImageUrl(url)) return url;
-  return url.replace(imageExtensionRegex, ".webp");
+  return withBasePath(withoutBasePath(url).replace(imageExtensionRegex, ".webp"));
 };
 
 const rewriteSrcset = (srcset) =>
@@ -299,7 +300,10 @@ const replacePlaceholders = async (template, values) => {
   try {
     template = eta.renderString(template, templateData);
   } catch (error) {
-    console.warn(`Eta template error: ${error.message}`);
+    const source = values.filePath || values.url || values.title || "template";
+    throw new Error(`Unable to render ${source}: ${error.message}`, {
+      cause: error,
+    });
   }
 
   // Restore code blocks

package/src/rss.js

@@ -2,6 +2,7 @@ import fs from "fs/promises";
 import fsExtra from "fs-extra";
 import path from "path";
 import { defaultConfig } from "./config.js";
+import { withBasePath } from "./urls.js";
 
 // Escape XML special characters
 const escapeXml = (str) => {
@@ -40,8 +41,8 @@ const generateRssFeed = (feedConfig, pages, siteUrl) => {
     folder,
   } = typeof feedConfig === "string" ? { folder: feedConfig } : feedConfig;
 
-  const feedUrl = `${siteUrl}/${folder}/rss.xml`;
-  const feedLink = `${siteUrl}/${folder}`;
+  const feedUrl = `${siteUrl}${withBasePath(`/${folder}/rss.xml`)}`;
+  const feedLink = `${siteUrl}${withBasePath(`/${folder}`)}`;
 
   // Sort pages by date (newest first)
   const sortedPages = [...pages].sort((a, b) => {
@@ -94,7 +95,7 @@ const findPagesInFolder = (pages, folderName) => {
   const searchPages = (pageList) => {
     for (const page of pageList) {
       // Check if this page's URL starts with the folder path
-      if (page.url && page.url.startsWith(`/${folderName}/`) && !page.folder) {
+      if (page.route?.startsWith(`/${folderName}/`) && !page.folder) {
         found.push(page);
       }
       // Recursively search nested pages

package/src/server.js

@@ -0,0 +1,90 @@
+import fs from "fs/promises";
+import http from "http";
+import path from "path";
+
+import { baseDir, defaultConfig } from "./config.js";
+import { withoutBasePath } from "./urls.js";
+
+const contentTypes = {
+  ".css": "text/css; charset=utf-8",
+  ".gif": "image/gif",
+  ".html": "text/html; charset=utf-8",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain; charset=utf-8",
+  ".webmanifest": "application/manifest+json; charset=utf-8",
+  ".webp": "image/webp",
+  ".xml": "application/xml; charset=utf-8",
+};
+
+const readResponseFile = async (outputDirectory, pathname) => {
+  const route = withoutBasePath(pathname);
+  const relativePath = route.replace(/^\/+/, "");
+  const candidates = path.extname(relativePath)
+    ? [relativePath]
+    : [relativePath, path.join(relativePath, "index.html")];
+
+  for (const candidate of candidates) {
+    const filePath = path.resolve(outputDirectory, candidate);
+    if (!filePath.startsWith(`${outputDirectory}${path.sep}`)) continue;
+
+    try {
+      return { body: await fs.readFile(filePath), filePath, status: 200 };
+    } catch (error) {
+      if (error.code !== "ENOENT" && error.code !== "EISDIR") throw error;
+    }
+  }
+
+  const notFoundPath = path.join(outputDirectory, "404.html");
+  try {
+    return { body: await fs.readFile(notFoundPath), filePath: notFoundPath, status: 404 };
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    return {
+      body: Buffer.from("Not Found"),
+      filePath: "404.txt",
+      status: 404,
+    };
+  }
+};
+
+const startServer = async (
+  outputDir = "dist",
+  port = defaultConfig.server_port || 3000,
+) => {
+  const outputDirectory = path.resolve(baseDir, outputDir);
+  const server = http.createServer(async (request, response) => {
+    try {
+      const url = new URL(request.url || "/", "http://localhost");
+      const pathname = decodeURIComponent(url.pathname);
+      const result = await readResponseFile(outputDirectory, pathname);
+      const contentType =
+        contentTypes[path.extname(result.filePath).toLowerCase()] ||
+        "application/octet-stream";
+
+      response.writeHead(result.status, { "Content-Type": contentType });
+      response.end(request.method === "HEAD" ? undefined : result.body);
+    } catch (error) {
+      response.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
+      response.end(`Server error: ${error.message}`);
+    }
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", resolve);
+  });
+
+  const address = server.address();
+  const actualPort = typeof address === "object" ? address.port : port;
+  console.log(`Swifty server running at http://localhost:${actualPort}`);
+  return server;
+};
+
+export { readResponseFile, startServer };
+export default startServer;

package/src/sitemap.js

@@ -2,6 +2,7 @@ import fs from "fs/promises";
 import fsExtra from "fs-extra";
 import path from "path";
 import { defaultConfig } from "./config.js";
+import { withBasePath } from "./urls.js";
 
 const escapeXml = (str) =>
   String(str || "")
@@ -69,7 +70,9 @@ ${urls}
 const generateRobotsTxt = (siteUrl = "") => {
   const lines = ["User-agent: *", "Allow: /"];
   if (siteUrl) {
-    lines.push(`Sitemap: ${siteUrl.replace(/\/$/, "")}/sitemap.xml`);
+    lines.push(
+      `Sitemap: ${siteUrl.replace(/\/$/, "")}${withBasePath("/sitemap.xml")}`,
+    );
   }
   return `${lines.join("\n")}\n`;
 };