@daz4126/swifty 3.1.0 → 4.1.0

package/src/config.js

@@ -17,24 +17,105 @@ const dirs = {
   js: path.join(baseDir, "js"),
   partials: path.join(baseDir, "partials"),
   data: path.join(baseDir, "data"),
+  public: path.join(baseDir, "public"),
+  cache: path.join(baseDir, ".swifty-cache"),
 };
 
 async function loadConfig(dir) {
   const configFiles = ['config.yaml', 'config.yml', 'config.json'];
   for (const file of configFiles) {
     const filePath = path.join(dir, file);
+    let content;
+
+    try {
+      content = await fs.readFile(filePath, 'utf-8');
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      throw new Error(`Unable to read config ${filePath}: ${error.message}`, {
+        cause: error,
+      });
+    }
+
     try {
-      await fs.access(filePath);
-      const content = await fs.readFile(filePath, 'utf-8');
-      return file.endsWith('.json') ? JSON.parse(content) : yaml.load(content);
-    } catch {}
+      const config = file.endsWith('.json') ? JSON.parse(content) : yaml.load(content);
+      return validateConfig(config || {}, filePath);
+    } catch (error) {
+      throw new Error(`Unable to parse config ${filePath}: ${error.message}`, {
+        cause: error,
+      });
+    }
   }
   return {};
 }
 
+const validateConfig = (config, filePath = "config") => {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new TypeError(`${filePath} must contain a configuration object`);
+  }
+
+  const booleans = [
+    "minify",
+    "minify_html",
+    "minify_css",
+    "minify_js",
+    "morphing",
+    "prefetching",
+  ];
+  const positiveNumbers = [
+    "build_concurrency",
+    "image_quality",
+    "livereload_port",
+    "max_image_width",
+    "server_port",
+    "watcher_delay",
+    "watcher_interval",
+    "words_per_minute",
+  ];
+
+  for (const key of booleans) {
+    if (config[key] !== undefined && typeof config[key] !== "boolean") {
+      throw new TypeError(`${key} in ${filePath} must be a boolean`);
+    }
+  }
+  for (const key of positiveNumbers) {
+    if (
+      config[key] !== undefined &&
+      (!Number.isFinite(config[key]) || config[key] <= 0)
+    ) {
+      throw new TypeError(`${key} in ${filePath} must be a positive number`);
+    }
+  }
+  if (
+    config.base_path !== undefined &&
+    (typeof config.base_path !== "string" ||
+      /^(?:[a-z]+:)?\/\//i.test(config.base_path) ||
+      config.base_path.includes("..") ||
+      /[?#]/.test(config.base_path))
+  ) {
+    throw new TypeError(`base_path in ${filePath} must be a URL path`);
+  }
+  if (
+    config.responsive_image_widths !== undefined &&
+    (!Array.isArray(config.responsive_image_widths) ||
+      config.responsive_image_widths.some(
+        (width) => !Number.isInteger(width) || width <= 0,
+      ))
+  ) {
+    throw new TypeError(
+      `responsive_image_widths in ${filePath} must contain positive integers`,
+    );
+  }
+  if (config.rss_feeds !== undefined && !Array.isArray(config.rss_feeds)) {
+    throw new TypeError(`rss_feeds in ${filePath} must be an array`);
+  }
+
+  return config;
+};
+
 // Hardcoded defaults (used if not specified in config file)
 const builtInDefaults = {
   default_layout_name: 'default',
+  base_path: '',
   // Reading time calculation
   words_per_minute: 200,
   // Image optimization settings
@@ -49,6 +130,7 @@ const builtInDefaults = {
   minify_css: true,
   minify_js: true,
   // LiveReload and watcher settings
+  server_port: 3000,
   livereload_port: 35729,
   watcher_delay: 100,
   watcher_interval: 500,
@@ -64,15 +146,27 @@ const builtInDefaults = {
   navigation_cache_ttl: 15,
 };
 
-const loadedConfig = await loadConfig(baseDir);
-const hasConfig = (key) => Object.prototype.hasOwnProperty.call(loadedConfig, key);
+const defaultConfig = {};
+
+const reloadConfig = async () => {
+  const loadedConfig = await loadConfig(baseDir);
+  const hasConfig = (key) =>
+    Object.prototype.hasOwnProperty.call(loadedConfig, key);
 
-if (hasConfig('turbo')) {
-  console.warn('The "turbo" config option is deprecated. Use "morphing" and "prefetching" instead.');
-  if (!hasConfig('morphing')) {
-    loadedConfig.morphing = loadedConfig.turbo;
+  if (hasConfig('turbo')) {
+    console.warn('The "turbo" config option is deprecated. Use "morphing" and "prefetching" instead.');
+    if (!hasConfig('morphing')) {
+      loadedConfig.morphing = loadedConfig.turbo;
+    }
   }
-}
-const defaultConfig = { ...builtInDefaults, ...loadedConfig };
 
-export { baseDir, dirs, defaultConfig, loadConfig };
+  for (const key of Object.keys(defaultConfig)) {
+    delete defaultConfig[key];
+  }
+  Object.assign(defaultConfig, builtInDefaults, loadedConfig);
+  return defaultConfig;
+};
+
+await reloadConfig();
+
+export { baseDir, dirs, defaultConfig, loadConfig, reloadConfig, validateConfig };

package/src/data.js

@@ -24,36 +24,41 @@ async function loadData() {
     return data;
   }
 
+  let files;
   try {
-    const files = await fs.readdir(dirs.data);
+    files = await fs.readdir(dirs.data);
+  } catch (error) {
+    throw new Error(`Unable to read data directory ${dirs.data}: ${error.message}`, {
+      cause: error,
+    });
+  }
 
-    for (const file of files) {
-      const filePath = path.join(dirs.data, file);
-      const stat = await fs.stat(filePath);
+  for (const file of files) {
+    const filePath = path.join(dirs.data, file);
+    const stat = await fs.stat(filePath);
 
-      // Skip directories
-      if (stat.isDirectory()) continue;
+    // Skip directories
+    if (stat.isDirectory()) continue;
 
-      const ext = path.extname(file).toLowerCase();
-      const name = path.basename(file, ext);
+    const ext = path.extname(file).toLowerCase();
+    const name = path.basename(file, ext);
 
-      // Only process JSON and YAML files
-      if (!['.json', '.yaml', '.yml'].includes(ext)) continue;
+    // Only process JSON and YAML files
+    if (!['.json', '.yaml', '.yml'].includes(ext)) continue;
 
-      try {
-        const content = await fs.readFile(filePath, 'utf-8');
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
 
-        if (ext === '.json') {
-          data[name] = JSON.parse(content);
-        } else {
-          data[name] = yaml.load(content);
-        }
-      } catch (error) {
-        console.warn(`Error loading data file ${file}: ${error.message}`);
+      if (ext === '.json') {
+        data[name] = JSON.parse(content);
+      } else {
+        data[name] = yaml.load(content);
       }
+    } catch (error) {
+      throw new Error(`Unable to parse data file ${filePath}: ${error.message}`, {
+        cause: error,
+      });
     }
-  } catch (error) {
-    console.warn(`Error reading data directory: ${error.message}`);
   }
 
   dataCache = data;

package/src/frontmatter.js

@@ -0,0 +1,27 @@
+import yaml from "js-yaml";
+
+const frontMatterPattern =
+  /^---[ \t]*\r?\n([\s\S]*?)^---[ \t]*(?:\r?\n|$)/m;
+
+const parseFrontMatter = (source) => {
+  if (!/^---[ \t]*(?:\r?\n|$)/.test(source)) {
+    return { data: {}, content: source };
+  }
+
+  const match = source.match(frontMatterPattern);
+  if (!match) {
+    throw new Error("Front matter is missing a closing --- delimiter");
+  }
+
+  const data = yaml.load(match[1]) || {};
+  if (typeof data !== "object" || Array.isArray(data)) {
+    throw new TypeError("Front matter must contain a YAML object");
+  }
+
+  return {
+    data,
+    content: source.slice(match[0].length),
+  };
+};
+
+export { parseFrontMatter };

package/src/index.js

@@ -0,0 +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,129 +1,44 @@
-const protectBlocks = (content, pattern) => {
-  const blocks = [];
-  const protectedContent = content.replace(pattern, (match) => {
-    const token = `__SWIFTY_MINIFY_BLOCK_${blocks.length}__`;
-    blocks.push(match);
-    return token;
-  });
-
-  return {
-    content: protectedContent,
-    restore: (value) =>
-      value.replace(/__SWIFTY_MINIFY_BLOCK_(\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 minified = blocks.content
-    .replace(/<!--(?!\[if|<!|>)[\s\S]*?-->/g, "")
-    .replace(/\s{2,}/g, " ")
-    .replace(/>\s+</g, "><")
-    .trim();
-
-  return blocks.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 };