@daz4126/swifty 1.12.1 → 2.0.0

package/package.json

@@ -1,21 +1,20 @@
 {
   "name": "@daz4126/swifty",
-  "version": "1.12.1",
+  "version": "2.0.0",
   "main": "index.js",
   "type": "module",
   "bin": {
-    "swifty": "./cli.js"
+    "swifty": "./src/cli.js"
   },
   "files": [
-    "swifty.js",
-    "cli.js",
-    "init.js"
+    "src/"
   ],
   "scripts": {
     "test": "mocha",
-    "build": "node swifty.js",
-    "start": "node swifty.js && serve dist",
-    "init": "node init.js"
+    "build": "node src/build.js",
+    "start": "node src/build.js && serve dist",
+    "init": "node src/init.js",
+    "watch": "node src/watcher.js"
   },
   "keywords": [
     "static",
@@ -36,7 +35,9 @@
     "sharp": "^0.33.5"
   },
   "devDependencies": {
-    "mocha": "^11.1.0"
+    "chokidar-cli": "^3.0.0",
+    "mocha": "^11.1.0",
+    "npm-run-all": "^4.1.5"
   },
   "directories": {
     "test": "test"

package/src/assets.js

@@ -0,0 +1,80 @@
+import fs from "fs/promises";
+import fsExtra from "fs-extra";
+import path from "path";
+import sharp from "sharp";
+import { dirs, defaultConfig } from "./config.js";
+
+const validExtensions = {
+    css: [".css"],
+    js: [".js"],
+    images: [".png", ".jpg", ".jpeg", ".gif", ".svg"," .webp"],
+  };
+
+const ensureAndCopy = async (source, destination, validExts) => {
+  if (await fsExtra.pathExists(source)) {
+    await fsExtra.ensureDir(destination);
+
+    const files = await fs.readdir(source);
+    await Promise.all(
+      files
+        .filter(file => validExts.includes(path.extname(file).toLowerCase()))
+        .map(file => fsExtra.copy(path.join(source, file), path.join(destination, file)))
+    );
+    console.log(`Copied valid files from ${source} to ${destination}`);
+  } else {
+    console.log(`No ${path.basename(source)} found in ${source}`);
+  }
+};
+const copyAssets = async () => {
+  await ensureAndCopy(dirs.css, path.join(dirs.dist, 'css'), validExtensions.css);
+  await ensureAndCopy(dirs.js, path.join(dirs.dist, 'js'), validExtensions.js);
+  await ensureAndCopy(dirs.images, path.join(dirs.dist, 'images'), validExtensions.images);
+};
+async function optimizeImages() {
+  try {
+    const IMAGE_EXTENSIONS = ['.jpg', '.jpeg', '.png'];
+    const images_folder = path.join(dirs.dist, "images");
+    const files = await fs.readdir(images_folder);
+    
+    await Promise.all(files.map(async (file) => {
+      const filePath = path.join(images_folder, file);
+      const ext = path.extname(file).toLowerCase();
+    
+      if (!IMAGE_EXTENSIONS.includes(ext)) return;
+    
+      const optimizedPath = path.join(images_folder, `${path.basename(file, ext)}.webp`);
+    
+      if (filePath !== optimizedPath) {
+        const image = sharp(filePath);
+        const metadata = await image.metadata();
+        const originalWidth = metadata.width || 0;
+        const maxWidth = defaultConfig.max_image_size || 800;
+        const resizeWidth = Math.min(originalWidth, maxWidth);
+    
+        await image
+          .resize({ width: resizeWidth })
+          .toFormat('webp', { quality: 80 })
+          .toFile(optimizedPath);
+    
+        await fs.unlink(filePath);
+    
+        console.log(`Optimized ${file} -> ${optimizedPath}`);
+      }
+    }));
+  } catch (error) {
+    console.error('Error optimizing images:', error);
+  }
+};
+const generateAssetImports = async (dir, tagTemplate, validExts) => {
+  if (!(await fsExtra.pathExists(dir))) return '';
+  const files = await fs.readdir(dir);
+  return files
+    .filter(file => validExts.includes(path.extname(file).toLowerCase()))
+    .sort() 
+    .map(file => tagTemplate(file))
+    .join('\n');
+};
+const getCssImports = () => generateAssetImports(dirs.css, (file) => `<link rel="stylesheet" href="/css/${file}" />`, validExtensions.css);
+const getJsImports = () => generateAssetImports(dirs.js, (file) => `<script src="/js/${file}"></script>`, validExtensions.js);
+
+export { copyAssets, optimizeImages, getCssImports, getJsImports };

package/src/build.js

@@ -0,0 +1,13 @@
+import { copyAssets, optimizeImages } from "./assets.js";
+import { generatePages, createPages, addLinks } from "./pages.js";
+import { dirs } from "./config.js";
+
+async function buildSite() {
+  await copyAssets();
+  await optimizeImages();
+  const pages = await generatePages(dirs.pages);
+  await addLinks(pages);
+  await createPages(pages);
+}
+
+buildSite();

package/src/cli.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+const args = process.argv.slice(2);
+const command = args[0];
+let outDir = 'dist'; // default
+
+// Look for --out [folder]
+const outIndex = args.indexOf('--out');
+if (outIndex !== -1 && args[outIndex + 1]) {
+  outDir = args[outIndex + 1];
+}
+
+// Pass outDir as an environment variable
+process.env.OUT_DIR = outDir;
+
+switch (command) {
+  case "init":
+    import('./init.js');
+    break;
+  case "build":
+    import('./build.js');
+    break;
+  case "start":
+    import('./build.js').then(async () => {
+      const { execSync } = await import('child_process');
+      execSync(`npx serve ${process.env.OUT_DIR}`, { stdio: 'inherit' });
+    });
+    break;
+  default:
+    console.log(`Unknown command: ${command}`);
+    console.log(`Usage: swifty [init|build|start] [--out folder]`);
+}

package/src/config.js

@@ -0,0 +1,36 @@
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs/promises";
+import yaml from "js-yaml";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const isInstalled = process.cwd() !== __dirname;
+const baseDir = isInstalled ? process.cwd() : __dirname;
+
+const dirs = {
+  pages: path.join(baseDir, "pages"),
+  images: path.join(baseDir, "images"),
+  dist: path.join(baseDir, "dist"),
+  layouts: path.join(baseDir, "layouts"),
+  css: path.join(baseDir, "css"),
+  js: path.join(baseDir, "js"),
+  partials: path.join(baseDir, "partials"),
+};
+
+async function loadConfig(dir) {
+  const configFiles = ['config.yaml', 'config.yml', 'config.json'];
+  for (const file of configFiles) {
+    const filePath = path.join(dir, file);
+    try {
+      await fs.access(filePath);
+      const content = await fs.readFile(filePath, 'utf-8');
+      return file.endsWith('.json') ? JSON.parse(content) : yaml.load(content);
+    } catch {}
+  }
+  return {};
+}
+
+const defaultConfig = await loadConfig(baseDir);
+
+export { baseDir, dirs, defaultConfig, loadConfig };

package/src/layout.js

@@ -0,0 +1,43 @@
+import fs from "fs/promises";
+import fsExtra from "fs-extra";
+import path from "path";
+import { dirs, baseDir } from "./config.js";
+import { getCssImports, getJsImports } from "./assets.js";
+
+const layoutCache = new Map();
+const getLayout = async (layoutName) => {
+  if (!layoutName) return null;
+  if (!layoutCache.has(layoutName)) {
+    const layoutPath = path.join(dirs.layouts, `${layoutName}.html`);
+    if (await fsExtra.pathExists(layoutPath)) {
+      const layoutContent = await fs.readFile(layoutPath, 'utf-8');
+      layoutCache.set(layoutName, layoutContent);
+    } else {
+      return null;
+    }
+  }
+  return layoutCache.get(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');
+  const turboScript = `<script type="module">import * as Turbo from 'https://esm.sh/@hotwired/turbo';</script>`;
+  const css = await getCssImports();
+  const js = await getJsImports();
+  const imports = css + js;
+  const highlightCSS = `<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/styles/monokai-sublime.min.css">`;
+  const template = templateContent.replace('</head>', `${turboMetaTag}\n${turboScript}\n${highlightCSS}\n${imports}\n</head>`);
+  return template;
+};
+
+const applyLayoutAndWrapContent = async (page,content) => {
+    const layoutContent = await getLayout(page.data.layout !== undefined ? page.data.layout : page.layout);
+    if (!layoutContent) return content;
+    return layoutContent.replace(/\{\{\s*content\s*\}\}/g, content);
+  };
+
+const template = await createTemplate();
+
+export { getLayout, applyLayoutAndWrapContent, template };

package/src/pages.js

@@ -0,0 +1,210 @@
+// pages.js
+import { replacePlaceholders } from "./partials.js";
+import { dirs, defaultConfig, loadConfig } from "./config.js";
+import { template, applyLayoutAndWrapContent } from "./layout.js";
+import { marked } from "marked";
+import matter from "gray-matter";
+import fs from "fs/promises";
+import fsExtra from "fs-extra";
+import path from "path";
+
+const isValid = async (filePath) => {
+  try {
+    const stats = await fs.stat(filePath);
+    return stats.isDirectory() || path.extname(filePath) === '.md';
+  } catch (err) {
+    return false; // Handle errors like file not found
+  }
+};
+
+const capitalize = (str) => str.replace(/\b\w/g, (char) => char.toUpperCase());
+
+const tagsMap = new Map();
+const pageIndex = [];
+
+const addToTagMap = (tag, page) => {
+  if (!tagsMap.has(tag)) tagsMap.set(tag, []);
+  tagsMap.get(tag).push({ title: page.title, url: page.url });
+};
+
+const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
+  const pages = [];
+  const folderConfig = await loadConfig(sourceDir);
+  const config = { ...defaultConfig, ...parent?.data, ...folderConfig };
+
+  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);
+      if (!(await isValid(filePath))) 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 stats = await fs.stat(filePath);
+      const isDirectory = file.isDirectory();
+      const layoutFileExists = parent && await fsExtra.pathExists(`${dirs.layouts}/${parent.filename}.html`);
+      const layout = layoutFileExists ? parent.filename : parent ? parent.layout : "pages";
+
+      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, config.dateFormat),
+        updated_at: new Date(stats.mtime).toLocaleDateString(undefined, config.dateFormat),
+        date: new Date(stats.mtime).toLocaleDateString(undefined, config.dateFormat),
+        data: 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, { data: { ...page.data, ...data }, content });
+      }
+
+      // For directories, we defer recursion separately
+      return { page, isDirectory };
+    });
+
+    // Await all file processing
+    const fileResults = await Promise.all(filePromises);
+
+    // Now handle directories recursively
+    const directoryPromises = fileResults.map(async (result) => {
+      if (!result) return;
+
+      const { page, isDirectory } = result;
+
+      if (isDirectory) {
+        page.pages = await generatePages(page.filePath, baseDir, page);
+
+        page.pages.sort((a, b) => {
+          if (a.data.position && b.data.position) {
+            return a.data.position - b.data.position;
+          }
+          return new Date(a.updated_at) - new Date(b.updated_at);
+        });
+
+        page.content = await generateLinkList(page.filename, page.pages);
+      }
+
+      // Add tags
+      if (page.data.tags) {
+        page.data.tags.forEach(tag => addToTagMap(tag, page));
+      }
+
+      pages.push(page);
+      pageIndex.push({ url: page.url, title: page.title, nav: page.nav });
+    });
+
+    // Await all directory recursion
+    await Promise.all(directoryPromises);
+
+  } catch (err) {
+    console.error("Error reading directory:", err);
+  }
+
+  // Make Tags page
+  if (!parent && tagsMap.size) {
+    const tagLayout = await fsExtra.pathExists(`${dirs.layouts}/tags.html`);
+    const tagPage = {
+      url: "/tags",
+      nav: false,
+      folder: true,
+      name: "Tags",
+      title: "All Tags",
+      layout: "pages",
+      updated_at: new Date().toLocaleDateString(undefined, defaultConfig.dateFormat),
+      data: { ...config },
+      pages: []
+    };
+
+    for (const [tag, pagesForTag] of tagsMap) {
+      const page = {
+        name: tag,
+        title: tag,
+        updated_at: new Date().toLocaleDateString(undefined, defaultConfig.dateFormat),
+        url: `/tags/${tag}`,
+        layout: tagLayout ? "tags" : "pages",
+        data: { ...config, title: `Pages tagged with ${capitalize(tag)}` },
+      };
+      page.content = pagesForTag
+        .map(p => `* <a href="${p.url}">${p.title}</a>`)
+        .join('\n');
+
+      tagPage.pages.push(page);
+    }
+
+    tagPage.content = await generateLinkList("tags", tagPage.pages);
+    pages.push(tagPage);
+  }
+  return pages;
+};
+
+
+const generateLinkList = async (name,pages) => {
+  const partial = `${name}.md`;
+  const partialPath = path.join(dirs.partials, partial);
+  const linksPath = path.join(dirs.partials, "links.md");
+  // Check if either file exists in the 'partials' folder
+  const fileExists = await fsExtra.pathExists(partialPath);
+  const defaultExists = await fsExtra.pathExists(linksPath);
+  if (fileExists || defaultExists) {
+    const partial = await fs.readFile(fileExists ? partialPath : linksPath, "utf-8");
+    const content = await Promise.all(pages.map(page => replacePlaceholders(partial, page)));
+    return content.join('\n');
+  } else {
+    return `${pages.map(page => `<li><a href="${page.url}" class="${defaultConfig.link_class}">${page.title}</a></li>`).join`\n`}`
+  }
+};
+
+const render = async page => {
+  const htmlContent = marked.parse(page.content); // Markdown processed once
+  const wrappedContent = await applyLayoutAndWrapContent(page, htmlContent);
+  const htmlWithTemplate = template.replace(/\{\{\s*content\s*\}\}/g, wrappedContent);
+  const finalContent = await replacePlaceholders(htmlWithTemplate, page);
+  return finalContent;
+};
+
+const createPages = async (pages, distDir = dirs.dist) => {
+  await Promise.all(pages.map(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);
+    console.log(`Created file: ${pagePath}`);
+
+    if (page.folder) {
+      await createPages(page.pages, distDir); // Recursive still needs to await
+    }
+  }));
+};
+
+const addLinks = async (pages, parent) => {
+  for (const page of pages) {
+    page.data ||= {};
+    page.data.links_to_tags = page?.data?.tags?.length
+      ? page.data.tags.map(tag => `<a class="${defaultConfig.tag_class}" href="/tags/${tag}">${tag}</a>`).join`` : "";
+    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
+      : `<a class="${defaultConfig.breadcrumb_class}" href="/">Home</a>` + crumb;
+    page.data.links_to_children = page.pages ? await generateLinkList(page.filename, page.pages) : "";
+    page.data.links_to_siblings = await generateLinkList(page.parent?.filename || "pages", pages.filter(p => p.url !== page.url));
+    page.data.links_to_self_and_siblings = await generateLinkList(page.parent?.filename || "pages", pages);
+    page.data.nav_links = await generateLinkList("nav", pageIndex.filter(p => p.nav));
+    if (page.pages) {
+      await addLinks(page.pages, page);  // Recursive call
+    }
+  }
+};
+
+export { generatePages, createPages, pageIndex, addLinks };

package/src/partials.js

@@ -0,0 +1,63 @@
+import fs from "fs/promises";
+import fsExtra from "fs-extra";
+import path from "path";
+import { dirs } from "./config.js";
+import { marked } from "marked";
+
+const partialCache = new Map();
+
+
+const loadPartial = async (partialName) => {
+  if (partialCache.has(partialName)) {
+    return partialCache.get(partialName);
+  }
+
+  const partialPath = path.join(dirs.partials, `${partialName}.md`);
+  if (await fsExtra.pathExists(partialPath)) {
+    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 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());
+  };
+
+  // Replace partial includes
+  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
+  });
+  // replace image extensions with optimized extension
+  template = template.replace(/\.(png|jpe?g|webp)/gi, ".webp");
+  // Replace other placeholders **only outside of code blocks**
+  const codeBlockRegex = /```[\s\S]*?```|`[^`]+`|<(pre|code)[^>]*>[\s\S]*?<\/\1>/g;
+    const codeBlocks = [];
+    template = template.replace(codeBlockRegex, match => {
+        codeBlocks.push(match);
+        return `{{CODE_BLOCK_${codeBlocks.length - 1}}}`; // Temporary placeholder
+    });
+    // Replace 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)
+    });
+    // Restore code blocks
+    template = template.replace(/{{CODE_BLOCK_(\d+)}}/g, (_, index) => codeBlocks[index]);
+
+  return template;
+};
+
+export { loadPartial, replacePlaceholders };

package/src/watcher.js

@@ -0,0 +1,39 @@
+import chokidar from 'chokidar';
+import { exec } from 'child_process';
+
+// Define which files to watch (you can adjust based on your project structure)
+const filesToWatch = [
+    'pages/**/*.{md,html}',        // Watch JavaScript and HTML files in pages directory
+    'layouts/**/*.{html}',      // Watch JavaScript and HTML files in layouts directory
+    'images/**/*',                 // Watch all files in images directory
+    'css/**/*.{css}',              // Watch CSS files in css directory
+    'js/**/*.{js}',                // Watch JS files in js directory
+    'partials/**/*.{md,html}',     // Watch JavaScript and HTML files in partials directory
+    'template.html',                   // Watch the template HTML file
+    'config.yaml', 'config.yml', 'config.json'  // Watch YAML and JSON config files
+  ];
+const buildScript = 'npm run build';  // Your build script command
+
+// Initialize watcher
+const watcher = chokidar.watch(filesToWatch, {
+    persistent: true,
+    debounceDelay: 200  // Wait 200ms after the last change to trigger the build
+  })
+
+// Event listener for file changes
+watcher.on('change', path => {
+  console.log(`File ${path} has been changed. Running build...`);
+  exec(buildScript, (error, stdout, stderr) => {
+    if (error) {
+      console.error(`Error executing build: ${error.message}`);
+      return;
+    }
+    if (stderr) {
+      console.error(`stderr: ${stderr}`);
+      return;
+    }
+    console.log(stdout);  // Output from build process
+  });
+});
+
+console.log(`Watching files for changes ...`);

package/cli.js

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-
-const args = process.argv.slice(2);
-
-switch (args[0]) {
-  case "init":
-    import('./init.js');
-    break;
-  case "build":
-    import('./swifty.js');
-    break;
-  case "start":
-    // Optional: call build, then run a dev server
-    import('./swifty.js').then(async () => {
-      const { execSync } = await import('child_process');
-      execSync('npx serve dist', { stdio: 'inherit' });
-    });
-    break;
-  default:
-    console.log(`Unknown command: ${args[0]}`);
-    console.log(`Usage: swifty [init|build|start]`);
-}

package/swifty.js

@@ -1,504 +0,0 @@
-import fs from "fs/promises";
-import fsExtra from "fs-extra";
-import path from "path";
-import matter from "gray-matter";
-import yaml from "js-yaml";
-import sharp from "sharp";
-import { fileURLToPath } from "url";
-import { marked } from "marked";
-import { markedHighlight } from "marked-highlight";
-import hljs from 'highlight.js';
-
-// Directories
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Determine the project root directory
-const isInstalled = process.cwd() !== __dirname;
-const baseDir = isInstalled ? process.cwd() : __dirname;
-
-const dirs = {
-  pages: path.join(baseDir, 'pages'),
-  images: path.join(baseDir, 'images'),
-  dist: path.join(baseDir, 'dist'),
-  layouts: path.join(baseDir, 'layouts'),
-  css: path.join(baseDir, 'css'),
-  js: path.join(baseDir, 'js'),
-  partials: path.join(baseDir, 'partials'),
-};
-
-marked.use(
-  markedHighlight({
-    langPrefix: 'hljs language-',
-    highlight: (code, lang) => {
-      if (lang && hljs.getLanguage(lang)) {
-        return hljs.highlight(code, { language: lang }).value;
-      } else {
-        return hljs.highlightAuto(code).value; // Auto-detect the language
-      }
-    },
-  })
-);
-
-const tagsMap = new Map();
-const addToTagMap = (tag, page) => {
-  if (!tagsMap.has(tag)) tagsMap.set(tag, []);
-  tagsMap.get(tag).push({ title: page.title, url: page.url });
-};
-const pageIndex = [];
-const partialCache = new Map();
-
-const loadPartial = async (partialName) => {
-  if (partialCache.has(partialName)) {
-    return partialCache.get(partialName);
-  }
-
-  const partialPath = path.join(dirs.partials, `${partialName}.md`);
-  if (await fsExtra.pathExists(partialPath)) {
-    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>`;
-  }
-};
-
-// Valid file extensions for assets
-const validExtensions = {
-  css: ['.css'],
-  js: ['.js'],
-  images: ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp'],
-};
-
-// Ensure and copy valid assets
-const ensureAndCopy = async (source, destination, validExts) => {
-  if (await fsExtra.pathExists(source)) {
-    await fsExtra.ensureDir(destination);
-
-    const files = await fs.readdir(source);
-    await Promise.all(
-      files
-        .filter(file => validExts.includes(path.extname(file).toLowerCase()))
-        .map(file => fsExtra.copy(path.join(source, file), path.join(destination, file)))
-    );
-    console.log(`Copied valid files from ${source} to ${destination}`);
-  } else {
-    console.log(`No ${path.basename(source)} found in ${source}`);
-  }
-};
-
-// Helper function to capitalize words
-const capitalize = (str) => str.replace(/\b\w/g, (char) => char.toUpperCase());
-
-// Copy assets with file type validation
-const copyAssets = async () => {
-  await ensureAndCopy(dirs.css, path.join(dirs.dist, 'css'), validExtensions.css);
-  await ensureAndCopy(dirs.js, path.join(dirs.dist, 'js'), validExtensions.js);
-  await ensureAndCopy(dirs.images, path.join(dirs.dist, 'images'), validExtensions.images);
-};
-
-async function optimizeImages() {
-  try {
-    const IMAGE_EXTENSIONS = ['.jpg', '.jpeg', '.png'];
-    const images_folder = path.join(dirs.dist, "images");
-    const files = await fs.readdir(images_folder);
-    
-    await Promise.all(files.map(async (file) => {
-      const filePath = path.join(images_folder, file);
-      const ext = path.extname(file).toLowerCase();
-    
-      if (!IMAGE_EXTENSIONS.includes(ext)) return;
-    
-      const optimizedPath = path.join(images_folder, `${path.basename(file, ext)}.webp`);
-    
-      if (filePath !== optimizedPath) {
-        const image = sharp(filePath);
-        const metadata = await image.metadata();
-        const originalWidth = metadata.width || 0;
-        const maxWidth = defaultConfig.max_image_size || 800;
-        const resizeWidth = Math.min(originalWidth, maxWidth);
-    
-        await image
-          .resize({ width: resizeWidth })
-          .toFormat('webp', { quality: 80 })
-          .toFile(optimizedPath);
-    
-        await fs.unlink(filePath);
-    
-        console.log(`Optimized ${file} -> ${optimizedPath}`);
-      }
-    }));
-  } catch (error) {
-    console.error('Error optimizing images:', error);
-  }
-};
-
-// Utility: Generate HTML imports for assets
-const generateAssetImports = async (dir, tagTemplate, validExts) => {
-  if (!(await fsExtra.pathExists(dir))) return '';
-  const files = await fs.readdir(dir);
-  return files
-    .filter(file => validExts.includes(path.extname(file).toLowerCase()))
-    .sort() 
-    .map(file => tagTemplate(file))
-    .join('\n');
-};
-
-// Generate CSS and JS imports
-const getCssImports = () => generateAssetImports(dirs.css, (file) => `<link rel="stylesheet" href="/css/${file}" />`,validExtensions.css);
-const getJsImports = () => generateAssetImports(dirs.js, (file) => `<script src="/js/${file}"></script>`,validExtensions.js);
-
-const loadConfig = async (dir) => {
-  const configFiles = ['config.yaml', 'config.yml', 'config.json'];
-  for (const file of configFiles) {
-    const filePath = path.join(dir, file);
-    try {
-      await fs.access(filePath); // Check if file exists
-      const content = await fs.readFile(filePath, 'utf-8');
-      return file.endsWith('.json') ? JSON.parse(content) : yaml.load(content);
-    } catch (err) {
-      // File not found, continue to next option
-    }
-  }
-  return {}; // Return an empty object if no config file is found
-};
-
-// Default configuration
-const defaultConfig = await loadConfig(baseDir);
-
-// Utility: Cache and load layouts
-const layoutCache = new Map();
-const getLayout = async (layoutName) => {
-  if (!layoutName) return null;
-  if (!layoutCache.has(layoutName)) {
-    const layoutPath = path.join(dirs.layouts, `${layoutName}.html`);
-    if (await fsExtra.pathExists(layoutPath)) {
-      const layoutContent = await fs.readFile(layoutPath, 'utf-8');
-      layoutCache.set(layoutName, layoutContent);
-    } else {
-      return null;
-    }
-  }
-  return layoutCache.get(layoutName);
-};
-
-// Apply layout content to a page
-const applyLayout = async (layoutContent, config) => {
-  if (!layoutContent) return ['', ''];
-  const [before, after] = layoutContent.split(/{{\s*content\s*}}/);
-  return [
-    await replacePlaceholders(before || '', config),
-    await replacePlaceholders(after || '', config),
-  ];
-};
-
-// Utility: Apply layout and wrap content in a Turbo Frame
-const applyLayoutAndWrapContent = async (page,content) => {
-  const layoutContent = await getLayout(page.data.layout !== undefined ? page.data.layout || page.layout);
-  const [beforeLayout, afterLayout] = await applyLayout(layoutContent, page);
-  return `
-<turbo-frame id="content">
-  <head><title>${page.title} || ${page.data.sitename}</title></head>
-  ${beforeLayout}
-  ${content}
-  ${afterLayout}
-</turbo-frame>
-  `;
-};
-
-const isValid = async (filePath) => {
-  try {
-    const stats = await fs.stat(filePath);
-    return stats.isDirectory() || path.extname(filePath) === '.md';
-  } catch (err) {
-    return false; // Handle errors like file not found
-  }
-};
-
-const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
-  const pages = [];
-  const folderConfig = await loadConfig(sourceDir);
-  const config = {...defaultConfig,...parent?.data,...folderConfig};
-  try {
-    const files = await fs.readdir(sourceDir, { withFileTypes: true });
-    for (const file of files) {
-      const filePath = path.join(sourceDir, file.name);
-      const valid = await isValid(filePath);
-      if(!valid) continue;
-      const root = file.name === "index.md" && !parent;
-      const relativePath = path.relative(baseDir, filePath).replace(/\\/g, "/"); // Normalize slashes
-      const finalPath = `/${relativePath.replace(/\.md$/, "")}`;
-      const name = root ? "Home" : capitalize(file.name.replace(/\.md$/, "").replace(/-/g, " "));
-      const stats = await fs.stat(filePath);
-      const isDirectory = file.isDirectory();
-      const layoutFileExists = parent && await fsExtra.pathExists(dirs.layouts + "/" + parent.filename + ".html");
-      const layout = layoutFileExists ? parent.filename : parent ? parent.layout : "pages";
-
-      const page = {
-        name, root, layout,
-        filename: file.name.replace(/\.md$/, ""),
-        path: finalPath,
-        filepath: filePath,
-        url: root ? "/" : finalPath + ".html",
-        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,config.dateFormat),
-        updated_at: new Date(stats.mtime).toLocaleDateString(undefined,config.dateFormat),
-        date: new Date(stats.mtime).toLocaleDateString(undefined,config.dateFormat),
-        data: root ? {...defaultConfig} : {...config}
-      };
-      if (path.extname(file.name) === ".md") {
-        const markdownContent = await fs.readFile(filePath, "utf-8");
-        const { data, content } = matter(markdownContent);
-        const index = pages.findIndex(p => p.url === page.url);
-        if (index !== -1) {
-          Object.assign(pages[index], { data: { ...page.data, ...data }, content });
-          continue;
-        }
-        else Object.assign(page, { data: { ...page.data, ...data }, content });
-      }
-      if (isDirectory) {
-        page.pages = await generatePages(filePath, baseDir, page);
-        page.pages.sort((a, b) => {
-          if (a.data.position && b.data.position) {
-            return a.data.position - b.data.position; // Sort by position first
-          }
-          return new Date(a.updated_at) - new Date(b.updated_at); // If position is the same, sort by date
-        });
-        const index = pages.findIndex(p => p.url === page.url);
-        if (index !== -1) {
-          page.content = pages[index].content;
-          pages.splice(index, 1);
-        }
-        else page.content = await generateLinkList(page.filename,page.pages);     
-      }
-
-    // add tags
-    if (page.data.tags) page.data.tags.forEach(tag => addToTagMap(tag, page));
-
-    pages.push(page);
-    pageIndex.push({url: page.url, title: page.title || page.title, nav: page.nav})
-    }
-
-  } catch (err) {
-    console.error("Error reading directory:", err);
-  }
-
-  // make Tags page
-  if(!parent && tagsMap.size){
-    const tagLayout = await fsExtra.pathExists(dirs.layouts + "/tags.html");
-    const tagPage = {
-        path: "/tags",
-        url: "/tags.html",
-        nav: false,
-        folder: true,
-        name: "Tags",
-        title: "All Tags",
-        layout: "pages",
-        updated_at: new Date().toLocaleDateString(undefined,defaultConfig.dateFormat),
-        data: {...config},
-    }
-    tagPage.pages = [];
-    for (const [tag, pages] of tagsMap) {
-          const page = { 
-            name: tag,
-            title: tag,
-            updated_at: new Date().toLocaleDateString(undefined,defaultConfig.dateFormat),
-            path: `/tags/${tag}`,
-            url:  `/tags/${tag}.html`,
-            layout: tagLayout ? "tags" : "pages",
-            data: {...config, title: `Pages tagged with ${capitalize(tag)}`},
-          };
-          page.content = pages
-          .map(page =>`* <a href="${page.url}" data-turbo-frame="content" data-turbo-action="advance">${page.title}</a>`)
-          .join('\n');
-          tagPage.pages.push(page);
-    }
-    tagPage.content = await generateLinkList("tags",tagPage.pages);
-    pages.push(tagPage);
-  }
-  return pages;
-};
-
-const generateLinkList = async (name,pages) => {
-  const partial = `${name}.md`;
-  const partialPath = path.join(dirs.partials, partial);
-  const linksPath = path.join(dirs.partials, "links.md");
-  // Check if either file exists in the 'partials' folder
-  const fileExists = await fsExtra.pathExists(partialPath);
-  const defaultExists = await fsExtra.pathExists(linksPath);
-  if (fileExists || defaultExists) {
-    const partial = await fs.readFile(fileExists ? partialPath : linksPath, "utf-8");
-    const content = await Promise.all(pages.map(page => replacePlaceholders(partial, page)));
-    return content.join('\n');
-  } else {
-    return `${pages.map(page => `<li><a href="${page.url}" class="${defaultConfig.link_class}" data-turbo-frame="content">${page.title}</a></li>`).join`\n`}`
-  }
-};
-
-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);
-  const turboHTML = wrappedContent.replace(
-    /<a\s+([^>]*?)href="(\/[^"#?]+?)"(.*?)>/g,
-    (match, beforeHref, href, afterHref) => {
-      // Don't double-add .html
-      const fullHref = href.endsWith('.html') ? href : `${href}.html`;
-  
-      return `<a ${beforeHref}href="${fullHref}" data-turbo-frame="content" data-turbo-action="advance"${afterHref}>`;
-    }
-  );
-  return turboHTML;
-};
-
-// Function to read and render the index template
-const renderIndexTemplate = async (content, config) => {
-  // Read the template from pages folder
-  const templatePath = path.join(baseDir, 'template.html');
-  let templateContent = await fs.readFile(templatePath, 'utf-8');
-
-  // Add the meta tag for Turbo refresh method
-  const turboMetaTag = `<meta name="turbo-refresh-method" content="morph">`;
-  const css = await getCssImports();
-  const js = await getJsImports();
-  const imports = css + js;
-
-  const highlightCSS = `<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/styles/monokai-sublime.min.css">`;
-  templateContent = templateContent.replace('</head>', `${turboMetaTag}\n${imports}\n${highlightCSS}\n</head>`);
-  templateContent = await replacePlaceholders(templateContent,{...defaultConfig,...config,content})
-
-  // Add the missing script to the template
-  const turboScript = `
-<script type="module">
-  import * as Turbo from 'https://esm.sh/@hotwired/turbo';
-  const turboFrame = document.querySelector("turbo-frame#content");
-  function loadFrameContent() {
-    const path = window.location.pathname;
-    if(path !== "/") {
-      turboFrame.style.visibility = "hidden";
-      const pagePath = path.endsWith(".html") ? path : path + ".html";
-      if (turboFrame) Turbo.visit(pagePath, { frame: "content" });
-    }
-  }
-  loadFrameContent();
-  window.addEventListener("popstate", loadFrameContent);
-  document.addEventListener("turbo:frame-load", event => {
-    turboFrame.style.visibility = "visible";
-    window.scrollTo(0,0);
-    const frameSrc = turboFrame.getAttribute("src");
-    if (frameSrc && frameSrc.endsWith(".html")) {
-      const newPath = frameSrc.replace(".html", "");
-      if (window.location.pathname !== newPath) {
-        window.history.pushState({}, "", newPath);
-      }
-    }
-  });
-</script>
-`;
-  // Inject the script at the end of the template
-  templateContent = templateContent.replace('</body>', `${turboScript}</body>`);
-  return templateContent;
-};
-
-const createPages = async (pages, distDir=dirs.dist) => {
-  for (const page of pages) {
-    let html = await render(page);
-    if(page.root) html = await renderIndexTemplate(html,page.data);
-    const pagePath = path.join(distDir, page.root ? "/index.html" : page.url);
-    // If it's a folder, create the directory and recurse into its pages
-    if (page.folder) {
-      if (!(await fsExtra.pathExists(path.join(distDir, page.path)))) {
-        await fs.mkdir(path.join(distDir, page.path), { recursive: true });
-      }
-        // Recurse into pages inside the directory
-        await createPages(page.pages); // Process nested pages inside the folder
-    }
-    // create an HTML file
-    try {
-      await fs.writeFile(pagePath, html);
-      console.log(`Created file: ${pagePath}`);
-    } catch (err) {
-      console.error(`Error writing file ${pagePath}:`, err);
-    }
-  }
-};
-
-const replacePlaceholders = async (template, values) => {
-  const partialRegex = /{{\s*partial:\s*([\w-]+)\s*}}/g;
-
-  // Async replace function
-  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());
-  };
-
-  // Replace partial includes
-  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
-  });
-  // replace image extensions with optimized extension
-  template = template.replace(/\.(png|jpe?g|webp)/gi, ".webp");
-  // Replace other placeholders **only outside of code blocks**
-  const codeBlockRegex = /```[\s\S]*?```|`[^`]+`|<(pre|code)[^>]*>[\s\S]*?<\/\1>/g;
-    const codeBlocks = [];
-    template = template.replace(codeBlockRegex, match => {
-        codeBlocks.push(match);
-        return `{{CODE_BLOCK_${codeBlocks.length - 1}}}`; // Temporary placeholder
-    });
-    // Replace 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)
-    });
-    // Restore code blocks
-    template = template.replace(/{{CODE_BLOCK_(\d+)}}/g, (_, index) => codeBlocks[index]);
-
-  return template;
-};
-
-const addLinks = async (pages,parent) => {
-  pages.forEach(async page => {
-    page.data ||= {};
-    page.data.links_to_tags = page?.data?.tags?.length
-    ? page.data.tags.map(tag => `<a class="${defaultConfig.tag_class}" href="/tags/${tag}.html" data-turbo-frame="content" data-turbo-action="advance">${tag}</a>`).join`` : "";
-    const crumb = page.root ? "" : ` ${defaultConfig.breadcrumb_separator} <a class="${defaultConfig.breadcrumb_class}" href="${page.url}" data-turbo-frame="content" data-turbo-action="advance">${page.name}</a>`;
-    page.data.breadcrumbs = parent ? parent.data.breadcrumbs + crumb
-    : `<a class="${defaultConfig.breadcrumb_class}" href="/" data-turbo-frame="content" data-turbo-action="advance">Home</a>` + crumb;
-    page.data.links_to_children = page.pages ? await generateLinkList(page.filename,page.pages) : "";
-    page.data.links_to_siblings = await generateLinkList(page.parent?.filename || "pages",pages.filter(p => p.url !== page.url));
-    page.data.links_to_self_and_siblings = await generateLinkList(page.parent?.filename || "pages",pages);
-    page.data.nav_links = await generateLinkList("nav",pageIndex.filter(p => p.nav));
-    if(page.pages) {
-      await addLinks(page.pages,page)
-    }
-  });
-}
-
-// Main function to handle conversion and site generation
-const generateSite = async () => {
-  console.log('Starting build process...');
-  // Copy images, CSS, and JS files
-  await copyAssets();
-  await optimizeImages();
-  // Convert markdown in pages directory
-  const pages = await generatePages(dirs.pages);
-  await addLinks(pages);
-  await createPages(pages);
-};
-
-// Run the site generation process
-generateSite()
-  .then(() => console.log('🚀 Site generated successfully! 🥳'))
-  .catch(err => console.error('🛑 Error generating site:', err));