basecampjs 0.0.12 → 0.0.14

package/src/types.ts

@@ -0,0 +1,110 @@
+/**
+ * Core type definitions for BasecampJS
+ */
+
+// Configuration types
+export interface CompressionSettings {
+  quality: number;
+  formats: string[];
+  inputFormats: string[];
+  preserveOriginal: boolean;
+}
+
+export interface Integrations {
+  nunjucks: boolean;
+  liquid: boolean;
+  mustache: boolean;
+  vue: boolean;
+  alpine: boolean;
+}
+
+export interface ConfigHooks {
+  nunjucksEnv?: (env: unknown) => void;
+  liquidEnv?: (env: unknown) => void;
+}
+
+export interface CampsiteConfig {
+  siteName: string;
+  siteUrl: string;
+  srcDir: string;
+  outDir: string;
+  templateEngine: 'nunjucks' | 'liquid' | 'mustache' | string;
+  frontmatter: boolean;
+  minifyCSS: boolean;
+  minifyHTML: boolean;
+  cacheBustAssets: boolean;
+  excludeFiles: string[];
+  compressPhotos: boolean;
+  compressionSettings: CompressionSettings;
+  port: number;
+  integrations: Integrations;
+  hooks?: ConfigHooks;
+}
+
+// Page and rendering types
+export interface PageFrontmatter {
+  layout?: string;
+  title?: string;
+  date?: string;
+  author?: string;
+  markdown?: boolean;
+  [key: string]: unknown;
+}
+
+export interface PageContext {
+  site: {
+    name: string;
+    config: CampsiteConfig;
+  };
+  page: PageFrontmatter & {
+    content: string;
+    source: string;
+    path: string;
+  };
+  collections: Collections;
+  isActive: (url: string) => boolean;
+  [key: string]: unknown;
+}
+
+export interface RenderOptions {
+  pagesDir: string;
+  layoutsDir: string;
+  outDir: string;
+  env: unknown; // Nunjucks environment
+  liquidEnv: unknown; // Liquid environment
+  config: CampsiteConfig;
+  data: Collections;
+  partialsDir: string;
+}
+
+// Data types
+export type Collections = Record<string, unknown[]>;
+
+// Build options
+export interface BuildOptions {
+  skipImageCompression?: boolean;
+  devMode?: boolean;
+}
+
+// Asset processing types
+export interface ProcessedImage {
+  path: string;
+  format: string;
+  size: number;
+}
+
+export interface AssetMap {
+  [originalPath: string]: string;
+}
+
+// Sitemap types
+export interface SitemapUrl {
+  loc: string;
+  lastmod: string;
+}
+
+// Make content result
+export interface MakeContentResult {
+  success: boolean;
+  skipped: boolean;
+}

package/src/utils/fs.ts

@@ -0,0 +1,109 @@
+import { existsSync } from "fs";
+import { cp, mkdir, readdir, rm, stat, writeFile } from "fs/promises";
+import { basename, dirname, extname, join, relative } from "path";
+import { kolor } from "./logger.js";
+
+/**
+ * Ensure a directory exists (creates recursively if needed)
+ */
+export async function ensureDir(dir: string): Promise<void> {
+  await mkdir(dir, { recursive: true });
+}
+
+/**
+ * Clean (remove and recreate) a directory
+ */
+export async function cleanDir(dir: string): Promise<void> {
+  await rm(dir, { recursive: true, force: true });
+  await mkdir(dir, { recursive: true });
+}
+
+/**
+ * Recursively walk a directory and return all file paths
+ */
+export async function walkFiles(dir: string): Promise<string[]> {
+  const results: string[] = [];
+  if (!existsSync(dir)) return results;
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue;
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await walkFiles(full));
+    } else {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+/**
+ * Get file extension in lowercase
+ */
+export function getExt(filePath: string): string {
+  return extname(filePath).toLowerCase();
+}
+
+/**
+ * Check if a file should be excluded based on patterns
+ */
+export function shouldExcludeFile(filePath: string, excludePatterns: string[] | undefined): boolean {
+  if (!excludePatterns || excludePatterns.length === 0) return false;
+  
+  const fileName = basename(filePath).toLowerCase();
+  const ext = getExt(filePath);
+  
+  return excludePatterns.some(pattern => {
+    const normalized = pattern.toLowerCase();
+    // Support extension patterns like '.pdf' or 'pdf'
+    if (normalized.startsWith('.')) {
+      return ext === normalized;
+    }
+    if (normalized.startsWith('*.')) {
+      return ext === normalized.slice(1);
+    }
+    // Support exact filename matches
+    if (fileName === normalized) {
+      return true;
+    }
+    // Support glob-like patterns with wildcards
+    if (normalized.includes('*')) {
+      const regex = new RegExp('^' + normalized.replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+      return regex.test(fileName);
+    }
+    return false;
+  });
+}
+
+/**
+ * Copy public directory to output, respecting exclusions
+ */
+export async function copyPublic(publicDir: string, outDir: string, excludePatterns: string[] = []): Promise<void> {
+  if (!existsSync(publicDir)) return;
+  
+  const files = await walkFiles(publicDir);
+  for (const file of files) {
+    const rel = relative(publicDir, file);
+    
+    // Skip excluded files
+    if (shouldExcludeFile(file, excludePatterns)) {
+      console.log(kolor.dim(`Skipping excluded file: ${rel}`));
+      continue;
+    }
+    
+    const destPath = join(outDir, rel);
+    await ensureDir(dirname(destPath));
+    await cp(file, destPath);
+  }
+}
+
+/**
+ * Format bytes to human-readable string
+ */
+export function formatBytes(bytes: number): string {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}

package/src/utils/logger.ts

@@ -0,0 +1,27 @@
+import * as kolor from "kolorist";
+
+export { kolor };
+
+export function logError(message: string): void {
+  console.error(kolor.red(message));
+}
+
+export function logWarning(message: string): void {
+  console.log(kolor.yellow(message));
+}
+
+export function logSuccess(message: string): void {
+  console.log(kolor.green(message));
+}
+
+export function logInfo(message: string): void {
+  console.log(kolor.cyan(message));
+}
+
+export function logDim(message: string): void {
+  console.log(kolor.dim(message));
+}
+
+export function logBold(message: string): void {
+  console.log(kolor.bold(message));
+}

package/src/utils/paths.ts

@@ -0,0 +1,56 @@
+/**
+ * Convert output-relative path to URL path
+ */
+export function toUrlPath(outRel: string): string {
+  const normalized = outRel.replace(/\\/g, "/");
+  let path = `/${normalized}`;
+  // Remove trailing index.html for directory-style URLs
+  if (path.endsWith("index.html")) {
+    path = path.slice(0, -"index.html".length);
+  }
+  // Strip trailing slash except for root
+  if (path !== "/" && path.endsWith("/")) {
+    path = path.slice(0, -1);
+  }
+  return path || "/";
+}
+
+/**
+ * Normalize a URL for comparison (strips trailing slashes, .html extension)
+ */
+export function normalizeUrl(url: string | undefined | null): string {
+  if (!url) return "/";
+  let normalized = url.trim();
+  // Remove trailing slashes except for root
+  if (normalized !== "/" && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  // Add leading slash if missing
+  if (!normalized.startsWith("/")) {
+    normalized = "/" + normalized;
+  }
+  // Strip .html extension for comparison (so /about and /about.html match)
+  if (normalized !== "/" && normalized.endsWith(".html")) {
+    normalized = normalized.slice(0, -5);
+  }
+  return normalized;
+}
+
+/**
+ * Slugify text for use in URLs
+ */
+export function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .trim()
+    .replace(/[^\w\s-]/g, "")
+    .replace(/[\s_-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+/**
+ * Format a date to ISO date string (YYYY-MM-DD)
+ */
+export function formatDate(date: Date): string {
+  return date.toISOString().split("T")[0];
+}