@stati/core 1.0.0

package/dist/config/loader.d.ts

@@ -0,0 +1,23 @@
+import type { StatiConfig } from '../types.js';
+/**
+ * Loads and validates Stati configuration from the project directory.
+ * Searches for configuration files in order: stati.config.ts, stati.config.js, stati.config.mjs
+ *
+ * @param cwd - Current working directory to search for config files
+ * @returns Promise resolving to the merged configuration object
+ *
+ * @example
+ * ```typescript
+ * import { loadConfig } from 'stati';
+ *
+ * // Load config from current directory
+ * const config = await loadConfig();
+ *
+ * // Load config from specific directory
+ * const config = await loadConfig('/path/to/project');
+ * ```
+ *
+ * @throws {Error} When configuration file exists but contains invalid JavaScript/TypeScript
+ */
+export declare function loadConfig(cwd?: string): Promise<StatiConfig>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/config/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/config/loader.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAqB/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,UAAU,CAAC,GAAG,GAAE,MAAsB,GAAG,OAAO,CAAC,WAAW,CAAC,CAkClF"}

package/dist/config/loader.js

@@ -0,0 +1,73 @@
+import { existsSync } from 'fs';
+import { join, resolve } from 'path';
+import { pathToFileURL } from 'url';
+/**
+ * Default configuration values for Stati.
+ * Used as fallback when no configuration file is found.
+ */
+const DEFAULT_CONFIG = {
+    srcDir: 'site',
+    outDir: 'dist',
+    staticDir: 'public',
+    site: {
+        title: 'My Site',
+        baseUrl: 'http://localhost:3000',
+    },
+    isg: {
+        enabled: true,
+        ttlSeconds: 3600,
+        maxAgeCapDays: 365,
+    },
+};
+/**
+ * Loads and validates Stati configuration from the project directory.
+ * Searches for configuration files in order: stati.config.ts, stati.config.js, stati.config.mjs
+ *
+ * @param cwd - Current working directory to search for config files
+ * @returns Promise resolving to the merged configuration object
+ *
+ * @example
+ * ```typescript
+ * import { loadConfig } from 'stati';
+ *
+ * // Load config from current directory
+ * const config = await loadConfig();
+ *
+ * // Load config from specific directory
+ * const config = await loadConfig('/path/to/project');
+ * ```
+ *
+ * @throws {Error} When configuration file exists but contains invalid JavaScript/TypeScript
+ */
+export async function loadConfig(cwd = process.cwd()) {
+    const configPaths = [
+        join(cwd, 'stati.config.ts'),
+        join(cwd, 'stati.config.js'),
+        join(cwd, 'stati.config.mjs'),
+    ];
+    let configPath = null;
+    for (const path of configPaths) {
+        if (existsSync(path)) {
+            configPath = path;
+            break;
+        }
+    }
+    if (!configPath) {
+        return DEFAULT_CONFIG;
+    }
+    try {
+        const configUrl = pathToFileURL(resolve(configPath)).href;
+        const module = await import(configUrl);
+        const userConfig = module.default || module;
+        return {
+            ...DEFAULT_CONFIG,
+            ...userConfig,
+            site: { ...DEFAULT_CONFIG.site, ...userConfig.site },
+            isg: { ...DEFAULT_CONFIG.isg, ...userConfig.isg },
+        };
+    }
+    catch (error) {
+        console.error('Error loading config:', error);
+        return DEFAULT_CONFIG;
+    }
+}

package/dist/core/build.d.ts

@@ -0,0 +1,51 @@
+import type { BuildStats } from '../types.js';
+/**
+ * Options for customizing the build process.
+ *
+ * @example
+ * ```typescript
+ * const options: BuildOptions = {
+ *   force: true,        // Force rebuild of all pages
+ *   clean: true,        // Clean output directory before build
+ *   configPath: './custom.config.js',  // Custom config file path
+ *   includeDrafts: true // Include draft pages in build
+ * };
+ * ```
+ */
+export interface BuildOptions {
+    /** Force rebuild of all pages, ignoring cache */
+    force?: boolean;
+    /** Clean the output directory before building */
+    clean?: boolean;
+    /** Path to a custom configuration file */
+    configPath?: string;
+    /** Include draft pages in the build */
+    includeDrafts?: boolean;
+}
+/**
+ * Builds the static site by processing content files and generating HTML pages.
+ * This is the main entry point for Stati's build process.
+ *
+ * @param options - Build configuration options
+ *
+ * @example
+ * ```typescript
+ * import { build } from 'stati';
+ *
+ * // Basic build
+ * await build();
+ *
+ * // Build with options
+ * await build({
+ *   clean: true,
+ *   force: true,
+ *   configPath: './custom.config.js'
+ * });
+ * ```
+ *
+ * @throws {Error} When configuration loading fails
+ * @throws {Error} When content processing fails
+ * @throws {Error} When template rendering fails
+ */
+export declare function build(options?: BuildOptions): Promise<BuildStats>;
+//# sourceMappingURL=build.d.ts.map

package/dist/core/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/core/build.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAgB,UAAU,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uCAAuC;IACvC,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAoFD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,UAAU,CAAC,CAyG3E"}

package/dist/core/build.js

@@ -0,0 +1,191 @@
+import fse from 'fs-extra';
+const { ensureDir, writeFile, copy, remove, pathExists, stat, readdir } = fse;
+import { join, dirname } from 'path';
+import { loadConfig } from '../config/loader.js';
+import { loadContent } from './content.js';
+import { createMarkdownProcessor, renderMarkdown } from './markdown.js';
+import { createTemplateEngine, renderPage } from './templates.js';
+import { buildNavigation } from './navigation.js';
+/**
+ * Recursively calculates the total size of a directory in bytes.
+ * Used for build statistics.
+ *
+ * @param dirPath - Path to the directory
+ * @returns Total size in bytes
+ */
+async function getDirectorySize(dirPath) {
+    if (!(await pathExists(dirPath))) {
+        return 0;
+    }
+    let totalSize = 0;
+    const items = await readdir(dirPath, { withFileTypes: true });
+    for (const item of items) {
+        const itemPath = join(dirPath, item.name);
+        if (item.isDirectory()) {
+            totalSize += await getDirectorySize(itemPath);
+        }
+        else {
+            const stats = await stat(itemPath);
+            totalSize += stats.size;
+        }
+    }
+    return totalSize;
+}
+/**
+ * Counts the number of files in a directory recursively.
+ * Used for build statistics.
+ *
+ * @param dirPath - Path to the directory
+ * @returns Total number of files
+ */
+async function countFilesInDirectory(dirPath) {
+    if (!(await pathExists(dirPath))) {
+        return 0;
+    }
+    let fileCount = 0;
+    const items = await readdir(dirPath, { withFileTypes: true });
+    for (const item of items) {
+        const itemPath = join(dirPath, item.name);
+        if (item.isDirectory()) {
+            fileCount += await countFilesInDirectory(itemPath);
+        }
+        else {
+            fileCount++;
+        }
+    }
+    return fileCount;
+}
+/**
+ * Formats build statistics for display.
+ *
+ * @param stats - Build statistics to format
+ * @returns Formatted statistics string
+ */
+function formatBuildStats(stats) {
+    const sizeKB = (stats.outputSizeBytes / 1024).toFixed(1);
+    const timeSeconds = (stats.buildTimeMs / 1000).toFixed(2);
+    let output = `📊 Build Statistics:
+  ⏱️  Build time: ${timeSeconds}s
+  📄 Pages built: ${stats.totalPages}
+  📦 Assets copied: ${stats.assetsCount}
+  💾 Output size: ${sizeKB} KB`;
+    if (stats.cacheHits !== undefined && stats.cacheMisses !== undefined) {
+        const totalCacheRequests = stats.cacheHits + stats.cacheMisses;
+        const hitRate = totalCacheRequests > 0 ? ((stats.cacheHits / totalCacheRequests) * 100).toFixed(1) : '0';
+        output += `
+  🎯 Cache hits: ${stats.cacheHits}/${totalCacheRequests} (${hitRate}%)`;
+    }
+    return output;
+}
+/**
+ * Builds the static site by processing content files and generating HTML pages.
+ * This is the main entry point for Stati's build process.
+ *
+ * @param options - Build configuration options
+ *
+ * @example
+ * ```typescript
+ * import { build } from 'stati';
+ *
+ * // Basic build
+ * await build();
+ *
+ * // Build with options
+ * await build({
+ *   clean: true,
+ *   force: true,
+ *   configPath: './custom.config.js'
+ * });
+ * ```
+ *
+ * @throws {Error} When configuration loading fails
+ * @throws {Error} When content processing fails
+ * @throws {Error} When template rendering fails
+ */
+export async function build(options = {}) {
+    const buildStartTime = Date.now();
+    console.log('🏗️  Building site...');
+    // Load configuration
+    const config = await loadConfig(options.configPath ? dirname(options.configPath) : process.cwd());
+    const outDir = join(process.cwd(), config.outDir);
+    // Create .stati cache directory
+    const cacheDir = join(process.cwd(), '.stati');
+    await ensureDir(cacheDir);
+    // Clean output directory if requested
+    if (options.clean) {
+        console.log('🧹 Cleaning output directory...');
+        await remove(outDir);
+    }
+    await ensureDir(outDir);
+    // Load all content
+    const pages = await loadContent(config, options.includeDrafts);
+    console.log(`📄 Found ${pages.length} pages`);
+    // Build navigation from pages
+    const navigation = buildNavigation(pages);
+    console.log(`🧭 Built navigation with ${navigation.length} top-level items`);
+    // Create processors
+    const md = await createMarkdownProcessor(config);
+    const eta = createTemplateEngine(config);
+    // Build context
+    const buildContext = { config, pages };
+    // Run beforeAll hook
+    if (config.hooks?.beforeAll) {
+        await config.hooks.beforeAll(buildContext);
+    }
+    // Render each page
+    for (const page of pages) {
+        console.log(`  Building ${page.url}`);
+        // Run beforeRender hook
+        if (config.hooks?.beforeRender) {
+            await config.hooks.beforeRender({ page, config });
+        }
+        // Render markdown to HTML
+        const htmlContent = renderMarkdown(page.content, md);
+        // Render with template
+        const finalHtml = await renderPage(page, htmlContent, config, eta, navigation, pages);
+        // Determine output path - fix the logic here
+        let outputPath;
+        if (page.url === '/') {
+            outputPath = join(outDir, 'index.html');
+        }
+        else if (page.url.endsWith('/')) {
+            outputPath = join(outDir, page.url, 'index.html');
+        }
+        else {
+            outputPath = join(outDir, `${page.url}.html`);
+        }
+        // Ensure directory exists and write file
+        await ensureDir(dirname(outputPath));
+        await writeFile(outputPath, finalHtml, 'utf-8');
+        // Run afterRender hook
+        if (config.hooks?.afterRender) {
+            await config.hooks.afterRender({ page, config });
+        }
+    }
+    // Copy static assets and count them
+    let assetsCount = 0;
+    const staticDir = join(process.cwd(), config.staticDir);
+    if (await pathExists(staticDir)) {
+        await copy(staticDir, outDir, { overwrite: true });
+        assetsCount = await countFilesInDirectory(staticDir);
+        console.log(`📦 Copied ${assetsCount} static assets`);
+    }
+    // Run afterAll hook
+    if (config.hooks?.afterAll) {
+        await config.hooks.afterAll(buildContext);
+    }
+    // Calculate build statistics
+    const buildEndTime = Date.now();
+    const buildStats = {
+        totalPages: pages.length,
+        assetsCount,
+        buildTimeMs: buildEndTime - buildStartTime,
+        outputSizeBytes: await getDirectorySize(outDir),
+        // Cache stats would be populated here when caching is implemented
+        cacheHits: 0,
+        cacheMisses: 0,
+    };
+    console.log('✅ Build complete!');
+    console.log(formatBuildStats(buildStats));
+    return buildStats;
+}

package/dist/core/content.d.ts

@@ -0,0 +1,19 @@
+import type { PageModel, StatiConfig } from '../types.js';
+/**
+ * Loads and parses all content files from the configured source directory.
+ *
+ * @param config - The STATI configuration object
+ * @param includeDrafts - Whether to include draft pages (marked with draft: true)
+ * @returns Array of parsed page models
+ *
+ * @example
+ * ```typescript
+ * // Load all content including drafts
+ * const pages = await loadContent(config, true);
+ *
+ * // Load only published content
+ * const publishedPages = await loadContent(config, false);
+ * ```
+ */
+export declare function loadContent(config: StatiConfig, includeDrafts?: boolean): Promise<PageModel[]>;
+//# sourceMappingURL=content.d.ts.map

package/dist/core/content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../src/core/content.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1D;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,WAAW,EACnB,aAAa,CAAC,EAAE,OAAO,GACtB,OAAO,CAAC,SAAS,EAAE,CAAC,CAyCtB"}

package/dist/core/content.js

@@ -0,0 +1,68 @@
+import glob from 'fast-glob';
+import fse from 'fs-extra';
+const { readFile } = fse;
+import matter from 'gray-matter';
+import { join, relative, dirname, basename } from 'path';
+/**
+ * Loads and parses all content files from the configured source directory.
+ *
+ * @param config - The STATI configuration object
+ * @param includeDrafts - Whether to include draft pages (marked with draft: true)
+ * @returns Array of parsed page models
+ *
+ * @example
+ * ```typescript
+ * // Load all content including drafts
+ * const pages = await loadContent(config, true);
+ *
+ * // Load only published content
+ * const publishedPages = await loadContent(config, false);
+ * ```
+ */
+export async function loadContent(config, includeDrafts) {
+    const contentDir = join(process.cwd(), config.srcDir);
+    // Exclude folders starting with underscore from content discovery
+    const files = await glob('**/*.md', {
+        cwd: contentDir,
+        absolute: true,
+        ignore: ['**/_*/**', '_*/**'],
+    });
+    const pages = [];
+    for (const file of files) {
+        const content = await readFile(file, 'utf-8');
+        const { data: frontMatter, content: markdown } = matter(content);
+        // Skip drafts unless explicitly included
+        if (frontMatter.draft && !includeDrafts) {
+            continue;
+        }
+        const relativePath = relative(contentDir, file);
+        const slug = computeSlug(relativePath);
+        const url = computeUrl(slug, frontMatter);
+        const page = {
+            slug,
+            url,
+            sourcePath: file,
+            frontMatter,
+            content: markdown,
+        };
+        if (frontMatter.publishedAt && typeof frontMatter.publishedAt === 'string') {
+            page.publishedAt = new Date(frontMatter.publishedAt);
+        }
+        pages.push(page);
+    }
+    return pages;
+}
+function computeSlug(relativePath) {
+    const dir = dirname(relativePath);
+    const name = basename(relativePath, '.md');
+    if (name === 'index') {
+        return dir === '.' ? '/' : `/${dir}`;
+    }
+    return dir === '.' ? `/${name}` : `/${dir}/${name}`;
+}
+function computeUrl(slug, frontMatter) {
+    if (frontMatter.permalink && typeof frontMatter.permalink === 'string') {
+        return frontMatter.permalink;
+    }
+    return slug.replace(/\/index$/, '/');
+}

package/dist/core/invalidate.d.ts

@@ -0,0 +1,2 @@
+export declare function invalidate(query?: string): Promise<void>;
+//# sourceMappingURL=invalidate.d.ts.map

package/dist/core/invalidate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidate.d.ts","sourceRoot":"","sources":["../../src/core/invalidate.ts"],"names":[],"mappings":"AAAA,wBAAsB,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM9D"}

package/dist/core/invalidate.js

@@ -0,0 +1,7 @@
+export async function invalidate(query) {
+    // TODO This will be implemented in Milestone 4 (ISG)
+    console.log('Invalidate functionality will be available in a future release');
+    if (query) {
+        console.log(`Query: ${query}`);
+    }
+}

package/dist/core/markdown.d.ts

@@ -0,0 +1,9 @@
+import MarkdownIt from 'markdown-it';
+import type { StatiConfig } from '../types.js';
+/**
+ * Creates and configures a MarkdownIt processor based on the provided configuration.
+ * Supports both plugin array format and configure function format.
+ */
+export declare function createMarkdownProcessor(config: StatiConfig): Promise<MarkdownIt>;
+export declare function renderMarkdown(content: string, md: MarkdownIt): string;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/core/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/core/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,aAAa,CAAC;AACrC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;GAGG;AACH,wBAAsB,uBAAuB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAuCtF;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,GAAG,MAAM,CAEtE"}

package/dist/core/markdown.js

@@ -0,0 +1,48 @@
+import MarkdownIt from 'markdown-it';
+/**
+ * Creates and configures a MarkdownIt processor based on the provided configuration.
+ * Supports both plugin array format and configure function format.
+ */
+export async function createMarkdownProcessor(config) {
+    const md = new MarkdownIt({
+        html: true,
+        linkify: true,
+        typographer: true,
+    });
+    // Apply plugins from array format
+    if (config.markdown?.plugins) {
+        for (const plugin of config.markdown.plugins) {
+            if (typeof plugin === 'string') {
+                // Plugin name only
+                try {
+                    const pluginModule = await import(`markdown-it-${plugin}`);
+                    const pluginFunction = pluginModule.default || pluginModule;
+                    md.use(pluginFunction);
+                }
+                catch (error) {
+                    console.warn(`Failed to load markdown plugin: markdown-it-${plugin}`, error);
+                }
+            }
+            else if (Array.isArray(plugin) && plugin.length >= 1) {
+                // Plugin name with options [name, options]
+                const [pluginName, options] = plugin;
+                try {
+                    const pluginModule = await import(`markdown-it-${pluginName}`);
+                    const pluginFunction = pluginModule.default || pluginModule;
+                    md.use(pluginFunction, options);
+                }
+                catch (error) {
+                    console.warn(`Failed to load markdown plugin: markdown-it-${pluginName}`, error);
+                }
+            }
+        }
+    }
+    // Apply user configuration function (this runs after plugins for override capability)
+    if (config.markdown?.configure) {
+        config.markdown.configure(md);
+    }
+    return md;
+}
+export function renderMarkdown(content, md) {
+    return md.render(content);
+}

package/dist/core/navigation.d.ts

@@ -0,0 +1,21 @@
+import type { PageModel, NavNode } from '../types.js';
+/**
+ * Builds a hierarchical navigation structure from pages.
+ * Groups pages by directory structure and sorts them appropriately.
+ *
+ * @param pages - Array of page models to build navigation from
+ * @returns Array of top-level navigation nodes
+ *
+ * @example
+ * ```typescript
+ * const pages = [
+ *   { url: '/blog/post-1', frontMatter: { title: 'Post 1', order: 2 } },
+ *   { url: '/blog/post-2', frontMatter: { title: 'Post 2', order: 1 } },
+ *   { url: '/about', frontMatter: { title: 'About' } }
+ * ];
+ * const nav = buildNavigation(pages);
+ * // Results in hierarchical structure with sorted blog posts
+ * ```
+ */
+export declare function buildNavigation(pages: PageModel[]): NavNode[];
+//# sourceMappingURL=navigation.d.ts.map

package/dist/core/navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../src/core/navigation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,OAAO,EAAE,CAyC7D"}