@terrymooreii/sia 1.0.2 → 2.0.1

package/lib/assets.js

@@ -0,0 +1,234 @@
+import { 
+  readdirSync, 
+  statSync, 
+  existsSync, 
+  mkdirSync, 
+  copyFileSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  rmdirSync
+} from 'fs';
+import { join, dirname, relative, extname } from 'path';
+
+// Supported asset extensions
+const IMAGE_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.gif', '.svg', '.webp', '.ico', '.avif'];
+const STATIC_EXTENSIONS = ['.css', '.js', '.json', '.xml', '.txt', '.pdf', '.woff', '.woff2', '.ttf', '.eot'];
+const ALL_ASSET_EXTENSIONS = [...IMAGE_EXTENSIONS, ...STATIC_EXTENSIONS];
+
+/**
+ * Check if a file is an asset
+ */
+export function isAsset(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return ALL_ASSET_EXTENSIONS.includes(ext);
+}
+
+/**
+ * Check if a file is an image
+ */
+export function isImage(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return IMAGE_EXTENSIONS.includes(ext);
+}
+
+/**
+ * Recursively get all files in a directory
+ */
+function getAllFiles(dir, fileList = []) {
+  if (!existsSync(dir)) {
+    return fileList;
+  }
+  
+  const items = readdirSync(dir);
+  
+  for (const item of items) {
+    const fullPath = join(dir, item);
+    const stat = statSync(fullPath);
+    
+    if (stat.isDirectory()) {
+      getAllFiles(fullPath, fileList);
+    } else {
+      fileList.push(fullPath);
+    }
+  }
+  
+  return fileList;
+}
+
+/**
+ * Ensure a directory exists
+ */
+export function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+/**
+ * Copy a single file
+ */
+export function copyFile(src, dest) {
+  ensureDir(dirname(dest));
+  copyFileSync(src, dest);
+}
+
+/**
+ * Copy all assets from source to destination
+ */
+export function copyAssets(srcDir, destDir) {
+  const copied = [];
+  
+  if (!existsSync(srcDir)) {
+    return copied;
+  }
+  
+  const files = getAllFiles(srcDir);
+  
+  for (const file of files) {
+    if (isAsset(file)) {
+      const relativePath = relative(srcDir, file);
+      const destPath = join(destDir, relativePath);
+      
+      copyFile(file, destPath);
+      copied.push(relativePath);
+    }
+  }
+  
+  return copied;
+}
+
+/**
+ * Copy images from the images folder
+ */
+export function copyImages(config) {
+  const imagesDir = join(config.inputDir, 'images');
+  const outputImagesDir = join(config.outputDir, 'images');
+  
+  const copied = copyAssets(imagesDir, outputImagesDir);
+  
+  if (copied.length > 0) {
+    console.log(`🖼️  Copied ${copied.length} images`);
+  }
+  
+  return copied;
+}
+
+/**
+ * Check if directory has CSS files
+ */
+function hasCssFiles(dir) {
+  if (!existsSync(dir)) return false;
+  
+  const files = getAllFiles(dir);
+  return files.some(f => extname(f).toLowerCase() === '.css');
+}
+
+/**
+ * Copy default styles to output
+ */
+export function copyDefaultStyles(config, defaultsDir) {
+  const defaultStylesDir = join(defaultsDir, 'styles');
+  const outputStylesDir = join(config.outputDir, 'styles');
+  
+  // Check if user has custom styles (must actually have CSS files)
+  const userStylesDir = join(config.rootDir, 'styles');
+  
+  if (hasCssFiles(userStylesDir)) {
+    // Copy user styles
+    const copied = copyAssets(userStylesDir, outputStylesDir);
+    console.log(`🎨 Copied ${copied.length} custom style files`);
+    return copied;
+  }
+  
+  // Copy default styles from the package
+  if (existsSync(defaultStylesDir)) {
+    const copied = copyAssets(defaultStylesDir, outputStylesDir);
+    console.log(`🎨 Copied ${copied.length} default style files`);
+    return copied;
+  }
+  
+  console.log('⚠️  No styles found');
+  return [];
+}
+
+/**
+ * Copy all static assets (non-image files from root)
+ */
+export function copyStaticAssets(config) {
+  const staticDirs = ['assets', 'static', 'public'];
+  let totalCopied = 0;
+  
+  for (const dirName of staticDirs) {
+    const srcDir = join(config.rootDir, dirName);
+    
+    if (existsSync(srcDir)) {
+      const destDir = join(config.outputDir, dirName);
+      const copied = copyAssets(srcDir, destDir);
+      totalCopied += copied.length;
+    }
+  }
+  
+  // Also copy favicon if it exists in root
+  const faviconSrc = join(config.rootDir, 'favicon.ico');
+  if (existsSync(faviconSrc)) {
+    copyFile(faviconSrc, join(config.outputDir, 'favicon.ico'));
+    totalCopied++;
+  }
+  
+  if (totalCopied > 0) {
+    console.log(`📁 Copied ${totalCopied} static assets`);
+  }
+  
+  return totalCopied;
+}
+
+/**
+ * Write a file with directory creation
+ */
+export function writeFile(filePath, content) {
+  ensureDir(dirname(filePath));
+  writeFileSync(filePath, content, 'utf-8');
+}
+
+/**
+ * Clean a directory (remove all contents)
+ */
+export function cleanDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    return;
+  }
+  
+  const items = readdirSync(dirPath);
+  
+  for (const item of items) {
+    const fullPath = join(dirPath, item);
+    const stat = statSync(fullPath);
+    
+    if (stat.isDirectory()) {
+      cleanDir(fullPath);
+      // Remove empty directory
+      try {
+        rmdirSync(fullPath);
+      } catch (e) {
+        // Ignore if directory not empty
+      }
+    } else {
+      unlinkSync(fullPath);
+    }
+  }
+}
+
+export default {
+  isAsset,
+  isImage,
+  ensureDir,
+  copyFile,
+  copyAssets,
+  copyImages,
+  copyDefaultStyles,
+  copyStaticAssets,
+  writeFile,
+  cleanDir
+};
+

package/lib/build.js

@@ -1,20 +1,264 @@
-import config from './readconfig.js'
-import { parseContent, generateBlogListPage } from './parse.js'
-import { mkdir, cpdir } from './helpers.js'
-import path from 'path'
-import { generateRSS } from './rss.js'
-const { app } = config
-
-export const build = () => {
-  mkdir(path.join(app.public))
-
-  const posts = parseContent()
-  generateBlogListPage(posts)
-  generateRSS(posts, app.feed.count)
-
-  cpdir(path.join(app.src, app.css), path.join(app.public, app.css))
-  cpdir(path.join(app.src, app.js), path.join(app.public, app.js))
-  cpdir(path.join(app.src, app.images), path.join(app.public, app.images))
-  cpdir(path.join(app.src, app.assets), path.join(app.public, app.assets))
-  console.log('Build success')
+import { existsSync, mkdirSync, rmSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { loadConfig } from './config.js';
+import { buildSiteData, paginate, getPaginationUrls } from './collections.js';
+import { createTemplateEngine, renderTemplate } from './templates.js';
+import { copyImages, copyDefaultStyles, copyStaticAssets, writeFile, ensureDir } from './assets.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const defaultsDir = join(__dirname, '..', 'defaults');
+
+/**
+ * Clean the output directory
+ */
+function cleanOutput(config) {
+  if (existsSync(config.outputDir)) {
+    rmSync(config.outputDir, { recursive: true, force: true });
+  }
+  mkdirSync(config.outputDir, { recursive: true });
+  console.log('🧹 Cleaned output directory');
+}
+
+/**
+ * Render and write a single content item
+ */
+function renderContentItem(env, item, siteData) {
+  const templateName = `${item.layout}.njk`;
+  
+  const html = renderTemplate(env, templateName, {
+    ...siteData,
+    page: item,
+    content: item.content,
+    title: item.title
+  });
+  
+  writeFile(item.outputPath, html);
+}
+
+/**
+ * Render paginated listing pages
+ */
+function renderPaginatedPages(env, siteData, baseUrl, outputBase, templateName, extraData = {}) {
+  const { paginatedCollections } = siteData;
+  const basePath = siteData.config.site.basePath || '';
+  
+  // Get all posts for the main blog listing
+  const posts = siteData.collections.posts || [];
+  const pages = paginate(posts, siteData.config.pagination.size);
+  
+  for (const page of pages) {
+    const pagination = getPaginationUrls(baseUrl, page, basePath);
+    
+    const html = renderTemplate(env, templateName, {
+      ...siteData,
+      pagination,
+      posts: page.items,
+      ...extraData
+    });
+    
+    const outputPath = page.pageNumber === 1
+      ? join(outputBase, 'index.html')
+      : join(outputBase, 'page', String(page.pageNumber), 'index.html');
+    
+    writeFile(outputPath, html);
+  }
+  
+  return pages.length;
+}
+
+/**
+ * Render tag pages
+ */
+function renderTagPages(env, siteData) {
+  const { tags, allTags, config } = siteData;
+  const basePath = config.site.basePath || '';
+  
+  // Render main tags listing page
+  const tagsHtml = renderTemplate(env, 'tags.njk', {
+    ...siteData,
+    title: 'Tags'
+  });
+  writeFile(join(config.outputDir, 'tags', 'index.html'), tagsHtml);
+  
+  // Render individual tag pages with pagination
+  for (const [tagSlug, tagData] of Object.entries(tags)) {
+    const tagPages = paginate(tagData.items, config.pagination.size);
+    const baseUrl = `/tags/${tagSlug}/`;
+    
+    for (const page of tagPages) {
+      const pagination = getPaginationUrls(baseUrl, page, basePath);
+      
+      const html = renderTemplate(env, 'tag.njk', {
+        ...siteData,
+        tag: tagData,
+        pagination,
+        posts: page.items,
+        title: `Tagged: ${tagData.name}`
+      });
+      
+      const outputPath = page.pageNumber === 1
+        ? join(config.outputDir, 'tags', tagSlug, 'index.html')
+        : join(config.outputDir, 'tags', tagSlug, 'page', String(page.pageNumber), 'index.html');
+      
+      writeFile(outputPath, html);
+    }
+  }
+  
+  console.log(`🏷️  Generated ${Object.keys(tags).length} tag pages`);
+}
+
+/**
+ * Render the homepage
+ */
+function renderHomepage(env, siteData) {
+  const html = renderTemplate(env, 'index.njk', {
+    ...siteData,
+    title: siteData.site.title
+  });
+  
+  writeFile(join(siteData.config.outputDir, 'index.html'), html);
+  console.log('🏠 Generated homepage');
+}
+
+/**
+ * Render the blog listing with pagination
+ */
+function renderBlogListing(env, siteData) {
+  const { config } = siteData;
+  const blogDir = join(config.outputDir, 'blog');
+  
+  const pageCount = renderPaginatedPages(
+    env,
+    siteData,
+    '/blog/',
+    blogDir,
+    'blog.njk'
+  );
+  
+  console.log(`📝 Generated ${pageCount} blog listing pages`);
+}
+
+/**
+ * Render notes listing
+ */
+function renderNotesListing(env, siteData) {
+  const { config, collections } = siteData;
+  const notes = collections.notes || [];
+  const basePath = config.site.basePath || '';
+  
+  if (notes.length === 0) return;
+  
+  const notesDir = join(config.outputDir, 'notes');
+  const pages = paginate(notes, config.pagination.size);
+  
+  for (const page of pages) {
+    const pagination = getPaginationUrls('/notes/', page, basePath);
+    
+    const html = renderTemplate(env, 'notes.njk', {
+      ...siteData,
+      pagination,
+      notes: page.items,
+      title: 'Notes'
+    });
+    
+    const outputPath = page.pageNumber === 1
+      ? join(notesDir, 'index.html')
+      : join(notesDir, 'page', String(page.pageNumber), 'index.html');
+    
+    writeFile(outputPath, html);
+  }
+  
+  console.log(`📋 Generated ${pages.length} notes listing pages`);
 }
+
+/**
+ * Generate RSS feed
+ */
+function renderRSSFeed(env, siteData) {
+  const { config, collections } = siteData;
+  const posts = collections.posts || [];
+  
+  const rss = renderTemplate(env, 'feed.njk', {
+    ...siteData,
+    posts,
+    buildDate: new Date().toUTCString()
+  });
+  
+  writeFile(join(config.outputDir, 'feed.xml'), rss);
+  console.log('📡 Generated RSS feed');
+}
+
+/**
+ * Main build function
+ */
+export async function build(options = {}) {
+  const startTime = Date.now();
+  
+  console.log('\n⚡ Sia - Building site...\n');
+  
+  // Load configuration
+  const config = loadConfig(options.rootDir || process.cwd());
+  
+  // Clean output directory if requested
+  if (options.clean !== false) {
+    cleanOutput(config);
+  }
+  
+  // Build site data (collections, tags, etc.)
+  const siteData = buildSiteData(config);
+  
+  // Create template engine
+  const env = createTemplateEngine(config);
+  
+  // Render all content items
+  let itemCount = 0;
+  
+  for (const [collectionName, items] of Object.entries(siteData.collections)) {
+    for (const item of items) {
+      renderContentItem(env, item, siteData);
+      itemCount++;
+    }
+  }
+  
+  console.log(`📄 Generated ${itemCount} content pages`);
+  
+  // Render listing pages
+  renderHomepage(env, siteData);
+  renderBlogListing(env, siteData);
+  renderNotesListing(env, siteData);
+  renderTagPages(env, siteData);
+  
+  // Generate RSS feed
+  renderRSSFeed(env, siteData);
+  
+  // Copy assets
+  copyImages(config);
+  copyDefaultStyles(config, defaultsDir);
+  copyStaticAssets(config);
+  
+  const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+  console.log(`\n✅ Build complete in ${duration}s`);
+  console.log(`📁 Output: ${config.outputDir}\n`);
+  
+  return { config, siteData };
+}
+
+/**
+ * Build command handler for CLI
+ */
+export async function buildCommand(options) {
+  try {
+    await build({
+      clean: options.clean !== false,
+      rootDir: process.cwd()
+    });
+  } catch (err) {
+    console.error('❌ Build failed:', err.message);
+    process.exit(1);
+  }
+}
+
+export default { build, buildCommand };
+

package/lib/collections.js

@@ -0,0 +1,195 @@
+import { loadAllCollections } from './content.js';
+
+/**
+ * Build tag collections from all content
+ */
+export function buildTagCollections(collections) {
+  const tags = {};
+  
+  // Iterate through all collections and gather tags
+  for (const [collectionName, items] of Object.entries(collections)) {
+    for (const item of items) {
+      if (item.tags && Array.isArray(item.tags)) {
+        for (const tag of item.tags) {
+          const normalizedTag = tag.toLowerCase().trim();
+          
+          if (!tags[normalizedTag]) {
+            tags[normalizedTag] = {
+              name: tag,
+              slug: normalizedTag.replace(/\s+/g, '-'),
+              items: [],
+              count: 0
+            };
+          }
+          
+          tags[normalizedTag].items.push({
+            ...item,
+            collection: collectionName
+          });
+          tags[normalizedTag].count++;
+        }
+      }
+    }
+  }
+  
+  // Sort items within each tag by date (newest first)
+  for (const tag of Object.values(tags)) {
+    tag.items.sort((a, b) => new Date(b.date) - new Date(a.date));
+  }
+  
+  return tags;
+}
+
+/**
+ * Get all unique tags sorted by count
+ */
+export function getAllTags(tagCollections) {
+  return Object.values(tagCollections)
+    .sort((a, b) => b.count - a.count);
+}
+
+/**
+ * Paginate an array of items
+ */
+export function paginate(items, pageSize = 10) {
+  const pages = [];
+  const totalPages = Math.ceil(items.length / pageSize);
+  
+  for (let i = 0; i < totalPages; i++) {
+    const start = i * pageSize;
+    const end = start + pageSize;
+    const pageItems = items.slice(start, end);
+    
+    pages.push({
+      items: pageItems,
+      pageNumber: i + 1,
+      totalPages,
+      totalItems: items.length,
+      isFirst: i === 0,
+      isLast: i === totalPages - 1,
+      previousPage: i > 0 ? i : null,
+      nextPage: i < totalPages - 1 ? i + 2 : null,
+      startIndex: start,
+      endIndex: Math.min(end, items.length)
+    });
+  }
+  
+  return pages;
+}
+
+/**
+ * Generate pagination URLs
+ * @param {string} baseUrl - The base URL path (without basePath)
+ * @param {object} pagination - Pagination object
+ * @param {string} basePath - Optional basePath for subpath hosting
+ */
+export function getPaginationUrls(baseUrl, pagination, basePath = '') {
+  const prefixedBaseUrl = basePath + baseUrl;
+  return {
+    ...pagination,
+    url: pagination.pageNumber === 1 
+      ? prefixedBaseUrl 
+      : `${prefixedBaseUrl}page/${pagination.pageNumber}/`,
+    previousUrl: pagination.previousPage 
+      ? (pagination.previousPage === 1 ? prefixedBaseUrl : `${prefixedBaseUrl}page/${pagination.previousPage}/`)
+      : null,
+    nextUrl: pagination.nextPage 
+      ? `${prefixedBaseUrl}page/${pagination.nextPage}/`
+      : null
+  };
+}
+
+/**
+ * Build the complete site data structure
+ */
+export function buildSiteData(config) {
+  // Load all content collections
+  const collections = loadAllCollections(config);
+  
+  // Build tag collections
+  const tagCollections = buildTagCollections(collections);
+  const allTags = getAllTags(tagCollections);
+  
+  console.log(`🏷️  Found ${allTags.length} unique tags`);
+  
+  // Create paginated collections for listings
+  const paginatedCollections = {};
+  
+  for (const [name, items] of Object.entries(collections)) {
+    paginatedCollections[name] = paginate(items, config.pagination.size);
+  }
+  
+  // Create paginated tag pages
+  const paginatedTags = {};
+  
+  for (const [tagSlug, tagData] of Object.entries(tagCollections)) {
+    paginatedTags[tagSlug] = paginate(tagData.items, config.pagination.size).map(page => ({
+      ...page,
+      tag: tagData
+    }));
+  }
+  
+  return {
+    config,
+    site: config.site,
+    collections,
+    paginatedCollections,
+    tags: tagCollections,
+    allTags,
+    paginatedTags
+  };
+}
+
+/**
+ * Get recent items across all collections
+ */
+export function getRecentItems(collections, limit = 10) {
+  const allItems = [];
+  
+  for (const items of Object.values(collections)) {
+    allItems.push(...items);
+  }
+  
+  return allItems
+    .sort((a, b) => new Date(b.date) - new Date(a.date))
+    .slice(0, limit);
+}
+
+/**
+ * Get related items based on shared tags
+ */
+export function getRelatedItems(item, collections, limit = 5) {
+  const related = [];
+  const itemTags = new Set(item.tags.map(t => t.toLowerCase()));
+  
+  for (const items of Object.values(collections)) {
+    for (const candidate of items) {
+      if (candidate.slug === item.slug) continue;
+      
+      const candidateTags = new Set(candidate.tags.map(t => t.toLowerCase()));
+      const sharedTags = [...itemTags].filter(t => candidateTags.has(t));
+      
+      if (sharedTags.length > 0) {
+        related.push({
+          ...candidate,
+          sharedTags: sharedTags.length
+        });
+      }
+    }
+  }
+  
+  return related
+    .sort((a, b) => b.sharedTags - a.sharedTags)
+    .slice(0, limit);
+}
+
+export default {
+  buildTagCollections,
+  getAllTags,
+  paginate,
+  getPaginationUrls,
+  buildSiteData,
+  getRecentItems,
+  getRelatedItems
+};
+