bunki 0.3.1 → 0.3.3

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/cli.js

@@ -28481,6 +28481,7 @@ var import_nunjucks = __toESM(require_nunjucks(), 1);
 var import_slugify = __toESM(require_slugify(), 1);
 import path6 from "path";
 var {Glob: Glob2 } = globalThis.Bun;
+import fs2 from "fs";
 
 // src/utils/markdown-utils.ts
 var import_gray_matter = __toESM(require_gray_matter(), 1);
@@ -32512,8 +32513,16 @@ class SiteGenerator {
   async copyStaticAssets() {
     const assetsDir = path6.join(this.options.templatesDir, "assets");
     const publicDir = path6.join(process.cwd(), "public");
+    async function dirExists(p) {
+      try {
+        const stat = await fs2.promises.stat(p);
+        return stat.isDirectory();
+      } catch {
+        return false;
+      }
+    }
     const assetsDirFile = Bun.file(assetsDir);
-    if (await assetsDirFile.exists()) {
+    if (await assetsDirFile.exists() && await dirExists(assetsDir)) {
       const assetGlob = new Glob2("**/*.*");
       const assetsOutputDir = path6.join(this.options.outputDir, "assets");
       await ensureDir(assetsOutputDir);
@@ -32528,23 +32537,30 @@ class SiteGenerator {
         await copyFile(file, targetPath);
       }
     }
-    const publicDirFile = Bun.file(publicDir);
-    if (await publicDirFile.exists()) {
-      const publicGlob = new Glob2("**/*.*");
-      for await (const file of publicGlob.scan({
-        cwd: publicDir,
-        absolute: true
-      })) {
-        const relativePath = path6.relative(publicDir, file);
-        const targetPath = path6.join(this.options.outputDir, relativePath);
-        const targetDir = path6.dirname(targetPath);
-        await ensureDir(targetDir);
-        const targetFile = Bun.file(targetPath);
-        if (!await targetFile.exists()) {
-          await copyFile(file, targetPath);
+    if (await dirExists(publicDir)) {
+      const copyRecursive = async (srcDir) => {
+        const entries = await fs2.promises.readdir(srcDir, { withFileTypes: true });
+        for (const entry of entries) {
+          const srcPath = path6.join(srcDir, entry.name);
+          const relativePath = path6.relative(publicDir, srcPath);
+          const destPath = path6.join(this.options.outputDir, relativePath);
+          if (!relativePath)
+            continue;
+          if (entry.isDirectory()) {
+            await ensureDir(destPath);
+            await copyRecursive(srcPath);
+          } else if (entry.isFile()) {
+            const targetFile = Bun.file(destPath);
+            if (!await targetFile.exists()) {
+              const targetDir = path6.dirname(destPath);
+              await ensureDir(targetDir);
+              await copyFile(srcPath, destPath);
+            }
+          }
         }
-      }
-      console.log("Copied public files to site");
+      };
+      await copyRecursive(publicDir);
+      console.log("Copied public files to site (including extensionless & dotfiles)");
     }
   }
   async generateRSSFeed() {
@@ -32679,10 +32695,10 @@ ${rssItems}
 
 // src/server.ts
 import path7 from "path";
-import fs2 from "fs";
+import fs3 from "fs";
 async function startServer(outputDir = DEFAULT_OUTPUT_DIR, port = 3000) {
   try {
-    const stats = await fs2.promises.stat(outputDir);
+    const stats = await fs3.promises.stat(outputDir);
     if (!stats.isDirectory()) {
       const msg = `Error: Output directory ${outputDir} does not exist or is not accessible.`;
       console.error(msg);

package/dist/config.d.ts

@@ -0,0 +1,11 @@
+import { SiteConfig } from "./types";
+export declare const DEFAULT_CONTENT_DIR: string;
+export declare const DEFAULT_OUTPUT_DIR: string;
+export declare const DEFAULT_TEMPLATES_DIR: string;
+export declare const DEFAULT_CONFIG_TS: string;
+export declare const DEFAULT_CONFIG_FILE: string;
+export declare function configExists(configPath?: string): Promise<boolean>;
+export declare function loadConfig(configPath?: string): Promise<SiteConfig>;
+export declare function getDefaultConfig(): SiteConfig;
+export declare function createDefaultConfig(configPath?: string): Promise<boolean>;
+export declare function saveConfig(config: SiteConfig, configPath?: string): Promise<boolean>;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./types";
+export { SiteGenerator } from "./site-generator";
+export { parseMarkdownDirectory } from "./parser";
+export { startServer } from "./server";
+export { DEFAULT_CONTENT_DIR, DEFAULT_OUTPUT_DIR, DEFAULT_TEMPLATES_DIR, DEFAULT_CONFIG_FILE, loadConfig, createDefaultConfig, configExists, saveConfig, } from "./config";
+export { extractExcerpt, convertMarkdownToHtml, parseMarkdownFile, } from "./utils/markdown-utils";
+export { findFilesByPattern, fileExists, readFileAsText, getBaseFilename, ensureDir, copyFile, } from "./utils/file-utils";
+export { uploadImages, DEFAULT_IMAGES_DIR } from "./utils/image-uploader";
+export { createUploader } from "./utils/s3-uploader";

package/dist/index.js

@@ -26002,6 +26002,7 @@ var import_nunjucks = __toESM(require_nunjucks(), 1);
 var import_slugify = __toESM(require_slugify(), 1);
 import path3 from "path";
 var {Glob: Glob2 } = globalThis.Bun;
+import fs2 from "fs";
 
 // src/utils/file-utils.ts
 var {Glob } = globalThis.Bun;
@@ -30052,8 +30053,16 @@ class SiteGenerator {
   async copyStaticAssets() {
     const assetsDir = path3.join(this.options.templatesDir, "assets");
     const publicDir = path3.join(process.cwd(), "public");
+    async function dirExists(p) {
+      try {
+        const stat = await fs2.promises.stat(p);
+        return stat.isDirectory();
+      } catch {
+        return false;
+      }
+    }
     const assetsDirFile = Bun.file(assetsDir);
-    if (await assetsDirFile.exists()) {
+    if (await assetsDirFile.exists() && await dirExists(assetsDir)) {
       const assetGlob = new Glob2("**/*.*");
       const assetsOutputDir = path3.join(this.options.outputDir, "assets");
       await ensureDir(assetsOutputDir);
@@ -30068,23 +30077,30 @@ class SiteGenerator {
         await copyFile(file, targetPath);
       }
     }
-    const publicDirFile = Bun.file(publicDir);
-    if (await publicDirFile.exists()) {
-      const publicGlob = new Glob2("**/*.*");
-      for await (const file of publicGlob.scan({
-        cwd: publicDir,
-        absolute: true
-      })) {
-        const relativePath = path3.relative(publicDir, file);
-        const targetPath = path3.join(this.options.outputDir, relativePath);
-        const targetDir = path3.dirname(targetPath);
-        await ensureDir(targetDir);
-        const targetFile = Bun.file(targetPath);
-        if (!await targetFile.exists()) {
-          await copyFile(file, targetPath);
+    if (await dirExists(publicDir)) {
+      const copyRecursive = async (srcDir) => {
+        const entries = await fs2.promises.readdir(srcDir, { withFileTypes: true });
+        for (const entry of entries) {
+          const srcPath = path3.join(srcDir, entry.name);
+          const relativePath = path3.relative(publicDir, srcPath);
+          const destPath = path3.join(this.options.outputDir, relativePath);
+          if (!relativePath)
+            continue;
+          if (entry.isDirectory()) {
+            await ensureDir(destPath);
+            await copyRecursive(srcPath);
+          } else if (entry.isFile()) {
+            const targetFile = Bun.file(destPath);
+            if (!await targetFile.exists()) {
+              const targetDir = path3.dirname(destPath);
+              await ensureDir(targetDir);
+              await copyFile(srcPath, destPath);
+            }
+          }
         }
-      }
-      console.log("Copied public files to site");
+      };
+      await copyRecursive(publicDir);
+      console.log("Copied public files to site (including extensionless & dotfiles)");
     }
   }
   async generateRSSFeed() {
@@ -30218,7 +30234,7 @@ ${rssItems}
 }
 // src/server.ts
 import path5 from "path";
-import fs2 from "fs";
+import fs3 from "fs";
 
 // src/config.ts
 import path4 from "path";
@@ -30350,7 +30366,7 @@ export default function(): SiteConfig {
 // src/server.ts
 async function startServer(outputDir = DEFAULT_OUTPUT_DIR, port = 3000) {
   try {
-    const stats = await fs2.promises.stat(outputDir);
+    const stats = await fs3.promises.stat(outputDir);
     if (!stats.isDirectory()) {
       const msg = `Error: Output directory ${outputDir} does not exist or is not accessible.`;
       console.error(msg);

package/dist/parser.d.ts

@@ -0,0 +1,2 @@
+import { Post } from "./types";
+export declare function parseMarkdownDirectory(contentDir: string): Promise<Post[]>;

package/dist/server.d.ts

@@ -0,0 +1 @@
+export declare function startServer(outputDir?: string, port?: number): Promise<Bun.Server>;

package/dist/site-generator.d.ts

@@ -0,0 +1,20 @@
+import { GeneratorOptions } from "./types";
+export declare class SiteGenerator {
+    private options;
+    private site;
+    private formatRSSDate;
+    private getPacificDate;
+    private createPagination;
+    constructor(options: GeneratorOptions);
+    initialize(): Promise<void>;
+    generate(): Promise<void>;
+    private generateYearArchives;
+    private generateIndexPage;
+    private generatePostPages;
+    private generateTagPages;
+    private generateStylesheet;
+    private fallbackCSSGeneration;
+    private copyStaticAssets;
+    private generateRSSFeed;
+    private generateSitemap;
+}

package/dist/types.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Post object representing a single markdown file
+ */
+export interface Post {
+    /** Title of the post */
+    title: string;
+    /** Date of the post in ISO format */
+    date: string;
+    /** Array of tags associated with the post */
+    tags: string[];
+    /** Map of tag names to their slugs */
+    tagSlugs: Record<string, string>;
+    /** Raw markdown content */
+    content: string;
+    /** Slug used in the URL */
+    slug: string;
+    /** URL path for this post */
+    url: string;
+    /** Brief excerpt from the post content */
+    excerpt: string;
+    /** Rendered HTML content */
+    html: string;
+}
+/**
+ * Configuration for CSS processing
+ */
+export interface CSSConfig {
+    /** Input CSS file path (relative to project root) */
+    input: string;
+    /** Output CSS file path (relative to output directory) */
+    output: string;
+    /** PostCSS config file path (relative to project root) */
+    postcssConfig?: string;
+    /** Whether to enable CSS processing */
+    enabled: boolean;
+    /** Whether to watch for changes in development */
+    watch?: boolean;
+}
+/**
+ * Configuration for the site
+ */
+export interface SiteConfig {
+    /** Site title */
+    title: string;
+    /** Site description */
+    description: string;
+    /** Base URL for the site (e.g., https://example.com) */
+    baseUrl: string;
+    /** Site identifier (used for metadata) */
+    domain: string;
+    /** Optional public URL for the bucket */
+    publicUrl?: string;
+    /** Optional S3 client configuration (accessKeyId, secretAccessKey, bucket, etc.) */
+    s3?: S3Config;
+    /** CSS processing configuration */
+    css?: CSSConfig;
+    /** Additional custom configuration options */
+    [key: string]: any;
+}
+/**
+ * Options for initializing the site generator
+ */
+export interface GeneratorOptions {
+    /** Directory containing markdown content */
+    contentDir: string;
+    /** Directory where generated files will be output */
+    outputDir: string;
+    /** Directory containing template files */
+    templatesDir: string;
+    /** Site configuration */
+    config: SiteConfig;
+}
+/**
+ * Data structure for tag information
+ */
+export interface TagData {
+    /** Name of the tag */
+    name: string;
+    /** URL-friendly slug version of the tag name */
+    slug: string;
+    /** Number of posts with this tag */
+    count: number;
+    /** Array of posts with this tag */
+    posts: Post[];
+    /** Optional description of the tag */
+    description?: string;
+}
+/**
+ * Pagination information for archives and tag pages
+ */
+export interface PaginationData {
+    /** Current page number */
+    currentPage: number;
+    /** Total number of pages */
+    totalPages: number;
+    /** Whether there is a next page */
+    hasNextPage: boolean;
+    /** Whether there is a previous page */
+    hasPrevPage: boolean;
+    /** Next page number or null if no next page */
+    nextPage: number | null;
+    /** Previous page number or null if no previous page */
+    prevPage: number | null;
+    /** Number of items per page */
+    pageSize: number;
+    /** Total number of items across all pages */
+    totalItems: number;
+    /** Base path for pagination URLs */
+    pagePath: string;
+}
+/**
+ * Data structure for blog information
+ */
+export interface Site {
+    /** Site identifier */
+    name: string;
+    /** Array of posts for the site */
+    posts: Post[];
+    /** Map of tag names to tag data */
+    tags: Record<string, TagData>;
+}
+/**
+ * Interface for uploaders (different services can implement this)
+ */
+export interface Uploader {
+    upload(sourcePath: string, config: SiteConfig): Promise<void>;
+}
+/**
+ * Interface for image uploaders
+ */
+export interface ImageUploader {
+    /**
+     * Upload all images from a directory
+     * @param imagesDir Directory containing images to upload
+     * @returns Record of image filenames to their public URLs
+     */
+    uploadImages(imagesDir: string): Promise<Record<string, string>>;
+}
+/**
+ * S3 configuration type
+ */
+export interface S3Config {
+    accessKeyId: string;
+    secretAccessKey: string;
+    bucket: string;
+    publicUrl: string;
+    /** S3 client options */
+    endpoint?: string;
+    region?: string;
+}
+/**
+ * Options for image upload
+ */
+export interface ImageUploadOptions {
+    domain?: string;
+    images?: string;
+    outputJson?: string;
+}

package/dist/utils/css-processor.d.ts

@@ -0,0 +1,27 @@
+import { CSSConfig } from "../types";
+export interface CSSProcessorOptions {
+    /** CSS configuration */
+    css: CSSConfig;
+    /** Project root directory */
+    projectRoot: string;
+    /** Output directory for the site */
+    outputDir: string;
+    /** Whether to run in verbose mode */
+    verbose?: boolean;
+}
+/**
+ * Process CSS using PostCSS
+ */
+export declare function processCSS(options: CSSProcessorOptions): Promise<void>;
+/**
+ * Watch CSS files for changes and reprocess
+ */
+export declare function watchCSS(options: CSSProcessorOptions): Promise<void>;
+/**
+ * Get default CSS configuration
+ */
+export declare function getDefaultCSSConfig(): CSSConfig;
+/**
+ * Validate CSS configuration
+ */
+export declare function validateCSSConfig(css: CSSConfig): string[];

package/dist/utils/file-utils.d.ts

@@ -0,0 +1,6 @@
+export declare function findFilesByPattern(pattern: string, directory: string, absolute?: boolean): Promise<string[]>;
+export declare function fileExists(filePath: string): Promise<boolean>;
+export declare function readFileAsText(filePath: string): Promise<string | null>;
+export declare function getBaseFilename(filePath: string, extension?: string): string;
+export declare function ensureDir(dirPath: string): Promise<void>;
+export declare function copyFile(sourcePath: string, targetPath: string): Promise<void>;

package/dist/utils/image-uploader.d.ts

@@ -0,0 +1,3 @@
+import { ImageUploadOptions } from "../types";
+export declare const DEFAULT_IMAGES_DIR: string;
+export declare function uploadImages(options?: ImageUploadOptions): Promise<Record<string, string>>;

package/dist/utils/markdown-utils.d.ts

@@ -0,0 +1,4 @@
+import { Post } from "../types";
+export declare function extractExcerpt(content: string, maxLength?: number): string;
+export declare function convertMarkdownToHtml(markdownContent: string): string;
+export declare function parseMarkdownFile(filePath: string): Promise<Post | null>;

package/dist/utils/s3-uploader.d.ts

@@ -0,0 +1,23 @@
+import { ImageUploader, S3Config, SiteConfig, Uploader } from "../types";
+/**
+ * Bun-native S3 uploader implementation
+ */
+export declare class S3Uploader implements Uploader, ImageUploader {
+    private s3Config;
+    private client;
+    constructor(s3Config: S3Config);
+    upload(sourcePath: string, config: SiteConfig): Promise<void>;
+    /**
+     * Get the public URL for a file in S3
+     * @param s3Path Path to the file within the bucket
+     * @returns The public URL for the file
+     */
+    private getPublicUrl;
+    uploadImages(imagesDir: string): Promise<Record<string, string>>;
+}
+/**
+ * Create an S3 uploader
+ * @param config The configuration for the uploader
+ * @returns An uploader instance
+ */
+export declare function createUploader(config: S3Config): Uploader & ImageUploader;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunki",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "An opinionated static site generator built with Bun featuring PostCSS integration and modern web development workflows",
   "main": "dist/index.js",
   "module": "dist/index.mjs",