@daz4126/swifty 2.10.0 → 2.12.0

package/README.md

@@ -13,13 +13,23 @@ Swifty uses convention over configuration to make it super simple to build blazi
 - **Code syntax highlighting** via highlight.js
 - **Tags and navigation** generated automatically
 - **RSS feed generation** for blogs and content folders
+- **Draft mode** for work-in-progress pages (visible in dev, hidden in production)
+- **Scheduled publishing** via future dates in front matter
+- **Contact forms** via third-party services (Formspree, Netlify Forms, etc.)
+- **Pagination** for folders with many pages
+- **Data files** - Load JSON/YAML data and use in templates
+- **Open Graph tags** - Auto-generated social sharing meta tags
+- **Word count & reading time** - Auto-calculated for blog posts
+- **Previous/next navigation** - Auto-generated links between sibling pages
+- **[Eta templating](https://eta.js.org/)** - Full JavaScript in templates with EJS syntax
 - **Optional [Turbo](https://turbo.hotwired.dev/)** for SPA-like transitions
 
 ## Quickstart
 
 ```bash
-npm install @daz4126/swifty
-npx swifty init
+npm install -g @daz4126/swifty
+swifty my-site
+cd my-site
 npx swifty start
 ```
 
@@ -32,6 +42,7 @@ your-site/
 ├── pages/          # Markdown content (folder structure = URLs)
 ├── layouts/        # HTML layout templates
 ├── partials/       # Reusable content snippets
+├── data/           # JSON/YAML data files
 ├── css/            # Stylesheets (auto-injected)
 ├── js/             # JavaScript (auto-injected)
 ├── images/         # Images (auto-optimized to WebP)
@@ -42,16 +53,18 @@ your-site/
 ## Commands
 
 ```bash
-npx swifty init             # Create new project structure
+npx swifty my-site          # Create new site in my-site/ folder
 npx swifty build            # Build static site to dist/ (for production)
 npx swifty start            # Build, watch, and serve at localhost:3000 (for development)
 npx swifty build --out dir  # Build to custom output directory
+npx swifty deploy "message" # Build, git add, commit, and push (message optional)
 ```
 
 ### Development vs Production
 
 - **`swifty start`** - For development. Includes live reload (auto-refreshes browser on file changes) and file watching with incremental builds for CSS/JS/images.
 - **`swifty build`** - For production deployment. Produces clean output without any development scripts.
+- **`swifty deploy "message"`** - Builds the site and commits/pushes to git in one command.
 
 ## Documentation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daz4126/swifty",
-  "version": "2.10.0",
+  "version": "2.12.0",
   "main": "index.js",
   "type": "module",
   "bin": {
@@ -26,6 +26,7 @@
   "description": "Super Speedy Static Site Generator",
   "dependencies": {
     "chokidar": "^4.0.0",
+    "eta": "^4.5.0",
     "fs-extra": "^11.2.0",
     "gray-matter": "^4.0.3",
     "highlight.js": "^11.11.1",
@@ -33,7 +34,7 @@
     "livereload": "^0.10.3",
     "marked": "^14.1.3",
     "marked-highlight": "^2.2.1",
-    "serve": "^14.2.4",
+    "serve": "^14.2.5",
     "sharp": "^0.33.5"
   },
   "devDependencies": {

package/src/assets.js

@@ -3,11 +3,64 @@ import fsExtra from "fs-extra";
 import path from "path";
 import sharp from "sharp";
 import { dirs, defaultConfig } from "./config.js";
+import { mapLimit } from "./concurrency.js";
+
+// Get file modification timestamp for cache busting
+const getFileMtime = async (filePath) => {
+  const stats = await fs.stat(filePath);
+  return Math.floor(stats.mtimeMs);
+};
 
 const validExtensions = {
   css: [".css"],
   js: [".js"],
-  images: [".png", ".jpg", ".jpeg", ".gif", ".svg", " .webp"],
+  images: [".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp"],
+};
+
+const optimizableImageExtensions = [".jpg", ".jpeg", ".png"];
+
+const getBuildConcurrency = () => defaultConfig.build_concurrency || 16;
+
+const isDestinationFresh = async (source, destination) => {
+  try {
+    const [sourceStats, destinationStats] = await Promise.all([
+      fs.stat(source),
+      fs.stat(destination),
+    ]);
+    return destinationStats.mtimeMs >= sourceStats.mtimeMs;
+  } catch (err) {
+    return false;
+  }
+};
+
+const copyIfStale = async (source, destination) => {
+  if (await isDestinationFresh(source, destination)) {
+    return false;
+  }
+
+  await fsExtra.copy(source, destination);
+  return true;
+};
+
+const optimizeImageToWebp = async (source, destination) => {
+  if (await isDestinationFresh(source, destination)) {
+    return false;
+  }
+
+  const image = sharp(source);
+  const metadata = await image.metadata();
+  const originalWidth = metadata.width || 0;
+  const maxWidth = defaultConfig.max_image_width || 800;
+  const imageQuality = defaultConfig.image_quality || 80;
+  const resizeOptions =
+    originalWidth > 0 ? { width: Math.min(originalWidth, maxWidth) } : {};
+
+  await image
+    .resize(resizeOptions)
+    .toFormat("webp", { quality: imageQuality })
+    .toFile(destination);
+
+  return true;
 };
 
 const ensureAndCopy = async (source, destination, validExts) => {
@@ -34,47 +87,47 @@ const copyAssets = async (outputDir = dirs.dist) => {
     validExtensions.css,
   );
   await ensureAndCopy(dirs.js, path.join(outputDir, "js"), validExtensions.js);
-  await ensureAndCopy(
-    dirs.images,
-    path.join(outputDir, "images"),
-    validExtensions.images,
-  );
 };
 async function optimizeImages(outputDir = dirs.dist) {
   try {
-    const IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png"];
-    const images_folder = path.join(outputDir, "images");
-    const files = await fs.readdir(images_folder);
-
-    await Promise.all(
-      files.map(async (file) => {
-        const filePath = path.join(images_folder, file);
+    if (!(await fsExtra.pathExists(dirs.images))) {
+      console.log(`No ${path.basename(dirs.images)} found in ${dirs.images}`);
+      return;
+    }
+
+    const imagesFolder = path.join(outputDir, "images");
+    await fsExtra.ensureDir(imagesFolder);
+
+    const files = await fs.readdir(dirs.images);
+
+    await mapLimit(
+      files.filter((file) =>
+        validExtensions.images.includes(path.extname(file).toLowerCase()),
+      ),
+      async (file) => {
+        const filePath = path.join(dirs.images, file);
         const ext = path.extname(file).toLowerCase();
 
-        if (!IMAGE_EXTENSIONS.includes(ext)) return;
+        if (!optimizableImageExtensions.includes(ext)) {
+          const destination = path.join(imagesFolder, file);
+          const copied = await copyIfStale(filePath, destination);
+          if (copied) {
+            console.log(`Copied ${file}`);
+          }
+          return;
+        }
 
         const optimizedPath = path.join(
-          images_folder,
+          imagesFolder,
           `${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);
-
+        const optimized = await optimizeImageToWebp(filePath, optimizedPath);
+        if (optimized) {
           console.log(`Optimized ${file} -> ${optimizedPath}`);
         }
-      }),
+      },
+      getBuildConcurrency(),
     );
   } catch (error) {
     console.error("Error optimizing images:", error);
@@ -83,34 +136,40 @@ async function optimizeImages(outputDir = dirs.dist) {
 const generateAssetImports = async (dir, tagTemplate, validExts) => {
   if (!(await fsExtra.pathExists(dir))) return "";
   const files = await fs.readdir(dir);
-  return files
+  const validFiles = files
     .filter((file) => validExts.includes(path.extname(file).toLowerCase()))
-    .sort()
-    .map((file) => tagTemplate(file))
-    .join("\n");
+    .sort();
+
+  const imports = await Promise.all(
+    validFiles.map(async (file) => {
+      const mtime = await getFileMtime(path.join(dir, file));
+      return tagTemplate(file, mtime);
+    })
+  );
+  return imports.join("\n");
 };
 const getCssImports = () =>
   generateAssetImports(
     dirs.css,
-    (file) => `<link rel="stylesheet" href="/css/${file}" />`,
+    (file, mtime) => `<link rel="stylesheet" href="/css/${file}?v=${mtime}" />`,
     validExtensions.css,
   );
 const getJsImports = () =>
   generateAssetImports(
     dirs.js,
-    (file) => `<script src="/js/${file}"></script>`,
+    (file, mtime) => `<script src="/js/${file}?v=${mtime}"></script>`,
     validExtensions.js,
   );
 const getCssPreloads = () =>
   generateAssetImports(
     dirs.css,
-    (file) => `<link rel="preload" href="/css/${file}" as="style" />`,
+    (file, mtime) => `<link rel="preload" href="/css/${file}?v=${mtime}" as="style" />`,
     validExtensions.css,
   );
 const getJsPreloads = () =>
   generateAssetImports(
     dirs.js,
-    (file) => `<link rel="preload" href="/js/${file}" as="script" />`,
+    (file, mtime) => `<link rel="preload" href="/js/${file}?v=${mtime}" as="script" />`,
     validExtensions.js,
   );
 
@@ -136,7 +195,6 @@ const copySingleAsset = async (filePath, outputDir = dirs.dist) => {
 
 // Process a single image
 const optimizeSingleImage = async (filePath, outputDir = dirs.dist) => {
-  const IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png"];
   const filename = path.basename(filePath);
   const ext = path.extname(filePath).toLowerCase();
   const imagesFolder = path.join(outputDir, "images");
@@ -144,26 +202,20 @@ const optimizeSingleImage = async (filePath, outputDir = dirs.dist) => {
   await fsExtra.ensureDir(imagesFolder);
 
   // For non-optimizable images (svg, webp, gif), just copy
-  if (!IMAGE_EXTENSIONS.includes(ext)) {
-    await fsExtra.copy(filePath, path.join(imagesFolder, filename));
-    console.log(`Copied ${filename}`);
+  if (!optimizableImageExtensions.includes(ext)) {
+    const copied = await copyIfStale(filePath, path.join(imagesFolder, filename));
+    if (copied) {
+      console.log(`Copied ${filename}`);
+    }
     return true;
   }
 
   // Optimize jpg/jpeg/png to webp
   const optimizedPath = path.join(imagesFolder, `${path.basename(filename, ext)}.webp`);
-  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);
-
-  console.log(`Optimized ${filename} -> ${path.basename(optimizedPath)}`);
+  const optimized = await optimizeImageToWebp(filePath, optimizedPath);
+  if (optimized) {
+    console.log(`Optimized ${filename} -> ${path.basename(optimizedPath)}`);
+  }
   return true;
 };
 

package/src/build.js

@@ -1,13 +1,69 @@
 import { copyAssets, optimizeImages } from "./assets.js";
 import { generatePages, createPages, addLinks } from "./pages.js";
 import { generateRssFeeds } from "./rss.js";
+import { generateSeoFiles } from "./sitemap.js";
 import { dirs } from "./config.js";
 
-export default async function build(outputDir) {
+export default async function build(outputDir = dirs.dist) {
+  const startTime = performance.now();
+  console.log("🚀 Starting build...");
+  
+  const copyStart = performance.now();
   await copyAssets(outputDir);
+  const copyTime = performance.now() - copyStart;
+  console.log(`📁 Assets copied in ${(copyTime / 1000).toFixed(2)}s`);
+  
+  const imageStart = performance.now();
   await optimizeImages(outputDir);
+  const imageTime = performance.now() - imageStart;
+  console.log(`🖼️  Images optimized in ${(imageTime / 1000).toFixed(2)}s`);
+  
+  const pagesStart = performance.now();
   const pages = await generatePages(dirs.pages);
+  const pagesTime = performance.now() - pagesStart;
+  console.log(`📄 Pages generated in ${(pagesTime / 1000).toFixed(2)}s`);
+  
+  const linksStart = performance.now();
   await addLinks(pages);
+  const linksTime = performance.now() - linksStart;
+  console.log(`🔗 Links added in ${(linksTime / 1000).toFixed(2)}s`);
+  
+  const createStart = performance.now();
   await createPages(pages, outputDir);
+  const createTime = performance.now() - createStart;
+  console.log(`✨ Pages created in ${(createTime / 1000).toFixed(2)}s`);
+  
+  const rssStart = performance.now();
   await generateRssFeeds(pages, outputDir);
+  const rssTime = performance.now() - rssStart;
+  console.log(`📡 RSS feeds generated in ${(rssTime / 1000).toFixed(2)}s`);
+
+  const seoStart = performance.now();
+  await generateSeoFiles(pages, outputDir);
+  const seoTime = performance.now() - seoStart;
+  console.log(`🧭 SEO files generated in ${(seoTime / 1000).toFixed(2)}s`);
+  
+  const totalTime = performance.now() - startTime;
+  console.log(`\n✅ Build completed in ${(totalTime / 1000).toFixed(2)}s`);
+  
+  // Performance summary
+  const stages = [
+    { name: "Assets", time: copyTime },
+    { name: "Images", time: imageTime },
+    { name: "Pages", time: pagesTime },
+    { name: "Links", time: linksTime },
+    { name: "Create", time: createTime },
+    { name: "RSS", time: rssTime },
+    { name: "SEO", time: seoTime }
+  ];
+  
+  const slowest = stages.sort((a, b) => b.time - a.time)[0];
+  if (slowest.time > totalTime * 0.3) {
+    console.log(`⚠️  Slowest stage: ${slowest.name} (${(slowest.time / 1000).toFixed(2)}s)`);
+  }
+  
+  // Force output to appear
+  if (process.stdout.isTTY) {
+    process.stdout.write('\n');
+  }
 }

package/src/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { spawn } from "child_process";
+import { spawn, execSync } from "child_process";
 
 const args = process.argv.slice(2);
 let outDir = "dist"; // default
@@ -14,13 +14,22 @@ if (outIndex !== -1 && args[outIndex + 1]) {
 // Pass outDir as an environment variable too (optional, still useful)
 process.env.OUT_DIR = outDir;
 
+const reservedCommands = ["build", "start", "watch", "deploy"];
+
 async function main() {
   const command = args[0];
 
+  // No arguments - show usage
+  if (!command) {
+    console.log(`Usage:`);
+    console.log(`  swifty <sitename>              Create a new site in <sitename> folder`);
+    console.log(`  swifty build [--out folder]    Build the site`);
+    console.log(`  swifty start [--out folder]    Build and serve with live reload`);
+    console.log(`  swifty deploy ["message"]      Build, commit, and push to git`);
+    return;
+  }
+
   switch (command) {
-    case "init":
-      await import("./init.js");
-      break;
     case "build": {
       const build = await import("./build.js");
       if (typeof build.default === "function") {
@@ -54,9 +63,44 @@ async function main() {
       }
       break;
     }
-    default:
-      console.log(`Unknown command: ${command}`);
-      console.log(`Usage: swifty [init|build|start|watch] [--out folder]`);
+    case "deploy": {
+      const commitMessage = args[1] || "Deploying latest build";
+
+      // Build the site
+      const build = await import("./build.js");
+      if (typeof build.default === "function") {
+        await build.default(outDir);
+      }
+
+      // Git operations
+      try {
+        console.log("Adding files to git...");
+        execSync("git add .", { stdio: "inherit" });
+
+        console.log("Committing changes...");
+        execSync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, {
+          stdio: "inherit",
+        });
+
+        console.log("Pushing to remote...");
+        execSync("git push", { stdio: "inherit" });
+
+        console.log("Deployed successfully!");
+      } catch (error) {
+        console.error("Deploy failed:", error.message);
+        process.exit(1);
+      }
+      break;
+    }
+    default: {
+      // Treat as sitename for new project creation
+      const sitename = command;
+      const init = await import("./init.js");
+      if (typeof init.default === "function") {
+        await init.default(sitename);
+      }
+      break;
+    }
   }
 }
 

package/src/concurrency.js

@@ -0,0 +1,25 @@
+const DEFAULT_CONCURRENCY = 16;
+
+const getConcurrencyLimit = (value = DEFAULT_CONCURRENCY) => {
+  const limit = Number(value);
+  return Number.isInteger(limit) && limit > 0 ? limit : DEFAULT_CONCURRENCY;
+};
+
+const mapLimit = async (items, mapper, concurrency = DEFAULT_CONCURRENCY) => {
+  const limit = Math.min(getConcurrencyLimit(concurrency), items.length || 1);
+  const results = new Array(items.length);
+  let index = 0;
+
+  const workers = Array.from({ length: limit }, async () => {
+    while (index < items.length) {
+      const currentIndex = index;
+      index += 1;
+      results[currentIndex] = await mapper(items[currentIndex], currentIndex);
+    }
+  });
+
+  await Promise.all(workers);
+  return results;
+};
+
+export { getConcurrencyLimit, mapLimit };

package/src/config.js

@@ -16,6 +16,7 @@ const dirs = {
   css: path.join(baseDir, "css"),
   js: path.join(baseDir, "js"),
   partials: path.join(baseDir, "partials"),
+  data: path.join(baseDir, "data"),
 };
 
 async function loadConfig(dir) {
@@ -31,6 +32,25 @@ async function loadConfig(dir) {
   return {};
 }
 
-const defaultConfig = await loadConfig(baseDir);
+// Hardcoded defaults (used if not specified in config file)
+const builtInDefaults = {
+  default_layout_name: 'default',
+  // Reading time calculation
+  words_per_minute: 200,
+  // Image optimization settings
+  max_image_width: 800,
+  image_quality: 80,
+  // LiveReload and watcher settings
+  livereload_port: 35729,
+  watcher_delay: 100,
+  watcher_interval: 500,
+  // Pagination
+  default_page_count: 2,
+  // Build safety
+  build_concurrency: 16,
+};
+
+const loadedConfig = await loadConfig(baseDir);
+const defaultConfig = { ...builtInDefaults, ...loadedConfig };
 
-export { baseDir, dirs, defaultConfig, loadConfig };
+export { baseDir, dirs, defaultConfig, loadConfig };

package/src/data.js

@@ -0,0 +1,70 @@
+import fs from "fs/promises";
+import path from "path";
+import yaml from "js-yaml";
+import fsExtra from "fs-extra";
+import { dirs } from "./config.js";
+
+let dataCache = null;
+
+/**
+ * Load all data files from the data/ folder
+ * Supports .json and .yaml/.yml files
+ * File name becomes the key: data/team.json -> data.team
+ */
+async function loadData() {
+  if (dataCache !== null) {
+    return dataCache;
+  }
+
+  const data = {};
+
+  // Check if data directory exists
+  if (!(await fsExtra.pathExists(dirs.data))) {
+    dataCache = data;
+    return data;
+  }
+
+  try {
+    const files = await fs.readdir(dirs.data);
+
+    for (const file of files) {
+      const filePath = path.join(dirs.data, file);
+      const stat = await fs.stat(filePath);
+
+      // Skip directories
+      if (stat.isDirectory()) continue;
+
+      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;
+
+      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}`);
+      }
+    }
+  } catch (error) {
+    console.warn(`Error reading data directory: ${error.message}`);
+  }
+
+  dataCache = data;
+  return data;
+}
+
+/**
+ * Clear the data cache (useful for watch mode)
+ */
+function clearDataCache() {
+  dataCache = null;
+}
+
+export { loadData, clearDataCache };