@stati/core 1.3.1 → 1.4.0

package/dist/core/utils/template-discovery.js

@@ -0,0 +1,111 @@
+import { join, dirname } from 'path';
+import { posix } from 'path';
+import { pathExists } from './fs.js';
+import { LAYOUT_TEMPLATE } from '../../constants.js';
+import { resolveSrcDir } from './paths.js';
+/**
+ * Shared template discovery utilities.
+ * Extracted from templates.ts and isg/deps.ts to eliminate duplication.
+ */
+/**
+ * Determines if the given page is a collection index page.
+ * A collection index page is one whose URL matches a directory path that contains other pages.
+ *
+ * @param page - The page to check
+ * @param allPages - All pages in the site (optional for simplified check)
+ * @returns True if the page is a collection index page
+ */
+export function isCollectionIndexPage(page, allPages) {
+    // Root index page is always a collection index
+    if (page.url === '/') {
+        return true;
+    }
+    // If we have all pages, do a proper check
+    if (allPages) {
+        // Check if this page's URL is a directory path that contains other pages
+        const pageUrlAsDir = page.url.endsWith('/') ? page.url : page.url + '/';
+        return allPages.some((otherPage) => otherPage.url !== page.url && otherPage.url.startsWith(pageUrlAsDir));
+    }
+    // Simplified version when we don't have all pages
+    // Assume any page ending in /index or at root is a collection page
+    return page.url.endsWith('/index') || page.slug === 'index';
+}
+/**
+ * Discovers layout files by searching up the directory hierarchy.
+ * Supports both explicit layout specification and automatic discovery.
+ *
+ * @param pagePath - The path to the page (relative to srcDir)
+ * @param config - Stati configuration
+ * @param explicitLayout - Explicit layout name from front-matter
+ * @param isIndexPage - Whether this is an aggregation/index page (enables index.eta lookup)
+ * @returns The layout file path (relative to srcDir) or null if none found
+ */
+export async function discoverLayout(pagePath, config, explicitLayout, isIndexPage) {
+    // Early return if required config values are missing
+    if (!config.srcDir) {
+        return null;
+    }
+    const srcDir = resolveSrcDir(config);
+    // If explicit layout is specified, use it
+    if (explicitLayout) {
+        const layoutPath = join(srcDir, `${explicitLayout}.eta`);
+        if (await pathExists(layoutPath)) {
+            return `${explicitLayout}.eta`;
+        }
+    }
+    // Get the directory of the current page
+    const pageDir = dirname(pagePath);
+    const pathSegments = pageDir === '.' ? [] : pageDir.split(/[/\\]/); // Handle both separators
+    // Search for layout.eta from current directory up to root
+    const dirsToSearch = [];
+    // Add current directory if not root
+    if (pathSegments.length > 0) {
+        for (let i = pathSegments.length; i > 0; i--) {
+            dirsToSearch.push(pathSegments.slice(0, i).join('/'));
+        }
+    }
+    // Add root directory
+    dirsToSearch.push('');
+    for (const dir of dirsToSearch) {
+        // For index pages, first check for index.eta in each directory
+        if (isIndexPage) {
+            const indexLayoutPath = dir ? join(srcDir, dir, 'index.eta') : join(srcDir, 'index.eta');
+            if (await pathExists(indexLayoutPath)) {
+                // Return relative path with forward slashes for Eta
+                const relativePath = dir ? `${dir}/index.eta` : 'index.eta';
+                return posix.normalize(relativePath);
+            }
+        }
+        // Then check for layout.eta as fallback
+        const layoutPath = dir ? join(srcDir, dir, LAYOUT_TEMPLATE) : join(srcDir, LAYOUT_TEMPLATE);
+        if (await pathExists(layoutPath)) {
+            // Return relative path with forward slashes for Eta
+            const relativePath = dir ? `${dir}/${LAYOUT_TEMPLATE}` : LAYOUT_TEMPLATE;
+            return posix.normalize(relativePath);
+        }
+    }
+    return null;
+}
+/**
+ * Gets the collection path for a given page URL.
+ * For index pages, returns the page's URL. For child pages, returns the parent directory.
+ *
+ * @param pageUrl - The page URL
+ * @returns The collection path
+ */
+export function getCollectionPathForPage(pageUrl) {
+    if (pageUrl === '/') {
+        return '/';
+    }
+    // If it's an index page (ends with /), return the URL as-is
+    if (pageUrl.endsWith('/')) {
+        return pageUrl;
+    }
+    // For non-index pages, return the parent directory
+    const lastSlashIndex = pageUrl.lastIndexOf('/');
+    if (lastSlashIndex === -1) {
+        return '/';
+    }
+    const parentPath = pageUrl.substring(0, lastSlashIndex + 1);
+    return parentPath === '' ? '/' : parentPath;
+}

package/dist/index.d.ts

@@ -19,15 +19,17 @@
  * await build({ clean: true });
  * ```
  */
-export type { StatiConfig, PageModel, FrontMatter, BuildContext, PageContext, BuildHooks, NavNode, ISGConfig, AgingRule, BuildStats, } from './types.js';
+export type { StatiConfig, PageModel, FrontMatter, BuildContext, PageContext, BuildHooks, NavNode, ISGConfig, AgingRule, BuildStats, } from './types/index.js';
 export type { BuildOptions } from './core/build.js';
 export type { DevServerOptions } from './core/dev.js';
+export type { PreviewServerOptions } from './core/preview.js';
 export type { InvalidationResult } from './core/invalidate.js';
 export { build } from './core/build.js';
 export { createDevServer } from './core/dev.js';
+export { createPreviewServer } from './core/preview.js';
 export { loadConfig } from './config/loader.js';
 export { invalidate } from './core/invalidate.js';
-import type { StatiConfig } from './types.js';
+import type { StatiConfig } from './types/index.js';
 /**
  * Helper function for defining Stati configuration with TypeScript IntelliSense.
  * Provides type checking and autocompletion for configuration options.

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,YAAY,EACV,WAAW,EACX,SAAS,EACT,WAAW,EACX,YAAY,EACZ,WAAW,EACX,UAAU,EACV,OAAO,EACP,SAAS,EACT,SAAS,EACT,UAAU,GACX,MAAM,YAAY,CAAC;AAEpB,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtD,YAAY,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAGlD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAE7D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,YAAY,EACV,WAAW,EACX,SAAS,EACT,WAAW,EACX,YAAY,EACZ,WAAW,EACX,UAAU,EACV,OAAO,EACP,SAAS,EACT,SAAS,EACT,UAAU,GACX,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtD,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,YAAY,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAGlD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAE7D"}

package/dist/index.js

@@ -21,6 +21,7 @@
  */
 export { build } from './core/build.js';
 export { createDevServer } from './core/dev.js';
+export { createPreviewServer } from './core/preview.js';
 export { loadConfig } from './config/loader.js';
 export { invalidate } from './core/invalidate.js';
 /**

package/dist/tests/utils/test-mocks.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Test mock utilities for Stati core tests.
+ * Centralized mock factory functions to reduce duplication across test files.
+ */
+/**
+ * Creates a complete set of hoisted mocks for build tests.
+ * Use this inside vi.hoisted() calls.
+ */
+export declare function createBuildTestMocksObject(): {
+    mockEnsureDir: import("vitest").Mock<(...args: any[]) => any>;
+    mockWriteFile: import("vitest").Mock<(...args: any[]) => any>;
+    mockCopy: import("vitest").Mock<(...args: any[]) => any>;
+    mockCopyFile: import("vitest").Mock<(...args: any[]) => any>;
+    mockRemove: import("vitest").Mock<(...args: any[]) => any>;
+    mockPathExists: import("vitest").Mock<(...args: any[]) => any>;
+    mockReaddir: import("vitest").Mock<(...args: any[]) => any>;
+    mockStat: import("vitest").Mock<(...args: any[]) => any>;
+    mockReadFile: import("vitest").Mock<(...args: any[]) => any>;
+    mockLoadConfig: import("vitest").Mock<(...args: any[]) => any>;
+    mockLoadContent: import("vitest").Mock<(...args: any[]) => any>;
+    mockCreateMarkdownProcessor: import("vitest").Mock<(...args: any[]) => any>;
+    mockRenderMarkdown: import("vitest").Mock<(...args: any[]) => any>;
+    mockCreateTemplateEngine: import("vitest").Mock<(...args: any[]) => any>;
+    mockRenderPage: import("vitest").Mock<(...args: any[]) => any>;
+    mockBuildNavigation: import("vitest").Mock<(...args: any[]) => any>;
+    mockLoadCacheManifest: import("vitest").Mock<(...args: any[]) => any>;
+    mockSaveCacheManifest: import("vitest").Mock<(...args: any[]) => any>;
+    mockShouldRebuildPage: import("vitest").Mock<(...args: any[]) => any>;
+    mockCreateCacheEntry: import("vitest").Mock<(...args: any[]) => any>;
+    mockUpdateCacheEntry: import("vitest").Mock<(...args: any[]) => any>;
+    mockWithBuildLock: import("vitest").Mock<(...args: any[]) => any>;
+    mockComputeContentHash: import("vitest").Mock<(...args: any[]) => any>;
+    mockComputeFileHash: import("vitest").Mock<(...args: any[]) => any>;
+    mockComputeInputsHash: import("vitest").Mock<(...args: any[]) => any>;
+    mockTrackTemplateDependencies: import("vitest").Mock<(...args: any[]) => any>;
+    mockComputeEffectiveTTL: import("vitest").Mock<(...args: any[]) => any>;
+    mockComputeNextRebuildAt: import("vitest").Mock<(...args: any[]) => any>;
+    mockIsPageFrozen: import("vitest").Mock<(...args: any[]) => any>;
+};
+/**
+ * Creates fs-extra module mock implementation.
+ */
+export declare function mockFsExtraModule(mocks: ReturnType<typeof createBuildTestMocksObject>): {
+    default: {
+        ensureDir: import("vitest").Mock<(...args: any[]) => any>;
+        writeFile: import("vitest").Mock<(...args: any[]) => any>;
+        copy: import("vitest").Mock<(...args: any[]) => any>;
+        copyFile: import("vitest").Mock<(...args: any[]) => any>;
+        remove: import("vitest").Mock<(...args: any[]) => any>;
+        pathExists: import("vitest").Mock<(...args: any[]) => any>;
+        readdir: import("vitest").Mock<(...args: any[]) => any>;
+        stat: import("vitest").Mock<(...args: any[]) => any>;
+        readFile: import("vitest").Mock<(...args: any[]) => any>;
+    };
+};
+/**
+ * Sets up standard module mocks for build tests.
+ * Call this after creating mocks with vi.hoisted().
+ */
+export declare function setupBuildModuleMocks(mocks: ReturnType<typeof createBuildTestMocksObject>): void;
+/**
+ * Sets up ISG-specific module mocks.
+ */
+export declare function setupISGModuleMocks(mocks: ReturnType<typeof createBuildTestMocksObject>): void;
+export declare const createFsExtraMocks: typeof createBuildTestMocksObject;
+export declare const createCoreModuleMocks: typeof createBuildTestMocksObject;
+export declare const createISGMocks: typeof createBuildTestMocksObject;
+export declare const createBuildTestMocks: typeof createBuildTestMocksObject;
+//# sourceMappingURL=test-mocks.d.ts.map

package/dist/tests/utils/test-mocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-mocks.d.ts","sourceRoot":"","sources":["../../../src/tests/utils/test-mocks.ts"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;;;GAGG;AACH,wBAAgB,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsCzC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,0BAA0B,CAAC;;;;;;;;;;;;EAcrF;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,0BAA0B,CAAC,QAuCzF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,0BAA0B,CAAC,QAgBvF;AAGD,eAAO,MAAM,kBAAkB,mCAA6B,CAAC;AAC7D,eAAO,MAAM,qBAAqB,mCAA6B,CAAC;AAChE,eAAO,MAAM,cAAc,mCAA6B,CAAC;AACzD,eAAO,MAAM,oBAAoB,mCAA6B,CAAC"}

package/dist/tests/utils/test-mocks.js

@@ -0,0 +1,125 @@
+import { vi } from 'vitest';
+/**
+ * Test mock utilities for Stati core tests.
+ * Centralized mock factory functions to reduce duplication across test files.
+ */
+/**
+ * Creates a complete set of hoisted mocks for build tests.
+ * Use this inside vi.hoisted() calls.
+ */
+export function createBuildTestMocksObject() {
+    return {
+        // fs-extra mocks
+        mockEnsureDir: vi.fn(),
+        mockWriteFile: vi.fn(),
+        mockCopy: vi.fn(),
+        mockCopyFile: vi.fn(),
+        mockRemove: vi.fn(),
+        mockPathExists: vi.fn(),
+        mockReaddir: vi.fn(),
+        mockStat: vi.fn(),
+        mockReadFile: vi.fn(),
+        // core module mocks
+        mockLoadConfig: vi.fn(),
+        mockLoadContent: vi.fn(),
+        mockCreateMarkdownProcessor: vi.fn(),
+        mockRenderMarkdown: vi.fn(),
+        mockCreateTemplateEngine: vi.fn(),
+        mockRenderPage: vi.fn(),
+        mockBuildNavigation: vi.fn(),
+        // ISG mocks
+        mockLoadCacheManifest: vi.fn(),
+        mockSaveCacheManifest: vi.fn(),
+        mockShouldRebuildPage: vi.fn(),
+        mockCreateCacheEntry: vi.fn(),
+        mockUpdateCacheEntry: vi.fn(),
+        mockWithBuildLock: vi.fn(),
+        // Hash mocks
+        mockComputeContentHash: vi.fn(),
+        mockComputeFileHash: vi.fn(),
+        mockComputeInputsHash: vi.fn(),
+        // Dependency tracking mocks
+        mockTrackTemplateDependencies: vi.fn(),
+        // TTL mocks
+        mockComputeEffectiveTTL: vi.fn(),
+        mockComputeNextRebuildAt: vi.fn(),
+        mockIsPageFrozen: vi.fn(),
+    };
+}
+/**
+ * Creates fs-extra module mock implementation.
+ */
+export function mockFsExtraModule(mocks) {
+    return {
+        default: {
+            ensureDir: mocks.mockEnsureDir,
+            writeFile: mocks.mockWriteFile,
+            copy: mocks.mockCopy,
+            copyFile: mocks.mockCopyFile,
+            remove: mocks.mockRemove,
+            pathExists: mocks.mockPathExists,
+            readdir: mocks.mockReaddir,
+            stat: mocks.mockStat,
+            readFile: mocks.mockReadFile,
+        },
+    };
+}
+/**
+ * Sets up standard module mocks for build tests.
+ * Call this after creating mocks with vi.hoisted().
+ */
+export function setupBuildModuleMocks(mocks) {
+    vi.mock('fs-extra', () => mockFsExtraModule(mocks));
+    vi.mock('../../config/loader.js', () => ({
+        loadConfig: mocks.mockLoadConfig,
+    }));
+    vi.mock('../../core/content.js', () => ({
+        loadContent: mocks.mockLoadContent,
+    }));
+    vi.mock('../../core/markdown.js', () => ({
+        createMarkdownProcessor: mocks.mockCreateMarkdownProcessor,
+        renderMarkdown: mocks.mockRenderMarkdown,
+    }));
+    vi.mock('../../core/templates.js', () => ({
+        createTemplateEngine: mocks.mockCreateTemplateEngine,
+        renderPage: mocks.mockRenderPage,
+    }));
+    vi.mock('../../core/navigation.js', () => ({
+        buildNavigation: mocks.mockBuildNavigation,
+    }));
+    vi.mock('../../core/isg/manifest.js', () => ({
+        loadCacheManifest: mocks.mockLoadCacheManifest,
+        saveCacheManifest: mocks.mockSaveCacheManifest,
+    }));
+    vi.mock('../../core/isg/builder.js', () => ({
+        shouldRebuildPage: mocks.mockShouldRebuildPage,
+        createCacheEntry: mocks.mockCreateCacheEntry,
+        updateCacheEntry: mocks.mockUpdateCacheEntry,
+    }));
+    vi.mock('../../core/isg/build-lock.js', () => ({
+        withBuildLock: mocks.mockWithBuildLock,
+    }));
+}
+/**
+ * Sets up ISG-specific module mocks.
+ */
+export function setupISGModuleMocks(mocks) {
+    vi.mock('../../core/isg/hash.js', () => ({
+        computeContentHash: mocks.mockComputeContentHash,
+        computeFileHash: mocks.mockComputeFileHash,
+        computeInputsHash: mocks.mockComputeInputsHash,
+    }));
+    vi.mock('../../core/isg/deps.js', () => ({
+        trackTemplateDependencies: mocks.mockTrackTemplateDependencies,
+    }));
+    vi.mock('../../core/isg/ttl.js', () => ({
+        computeEffectiveTTL: mocks.mockComputeEffectiveTTL,
+        computeNextRebuildAt: mocks.mockComputeNextRebuildAt,
+        isPageFrozen: mocks.mockIsPageFrozen,
+    }));
+}
+// Legacy exports for compatibility
+export const createFsExtraMocks = createBuildTestMocksObject;
+export const createCoreModuleMocks = createBuildTestMocksObject;
+export const createISGMocks = createBuildTestMocksObject;
+export const createBuildTestMocks = createBuildTestMocksObject;

package/dist/types/config.d.ts

@@ -0,0 +1,178 @@
+import type MarkdownIt from 'markdown-it';
+/**
+ * Configuration related type definitions
+ */
+/**
+ * Site-wide configuration settings.
+ * Contains global metadata and URL configuration for the static site.
+ *
+ * @example
+ * ```typescript
+ * const siteConfig: SiteConfig = {
+ *   title: "My Awesome Blog",
+ *   baseUrl: "https://myblog.com",
+ *   defaultLocale: "en-US"
+ * };
+ * ```
+ */
+export interface SiteConfig {
+    /** The site's title, used in templates and metadata */
+    readonly title: string;
+    /** Base URL for the site, used for absolute URL generation */
+    readonly baseUrl: string;
+    /** Default locale for internationalization (optional) */
+    readonly defaultLocale?: string;
+}
+/**
+ * Main configuration interface for Stati static site generator.
+ * Defines all options for site generation, including directories, templates, and features.
+ *
+ * @example
+ * ```typescript
+ * const config: StatiConfig = {
+ *   srcDir: 'site',
+ *   outDir: 'dist',
+ *   staticDir: 'public',
+ *   site: {
+ *     title: 'My Blog',
+ *     baseUrl: 'https://example.com'
+ *   },
+ *   markdown: {
+ *     configure: (md) => md.use(somePlugin)
+ *   }
+ * };
+ * ```
+ */
+export interface StatiConfig {
+    /** Source directory for content files (default: 'site') */
+    srcDir?: string;
+    /** Output directory for generated site (default: 'dist') */
+    outDir?: string;
+    /** Directory for static assets (default: 'public') */
+    staticDir?: string;
+    /** Site-wide configuration */
+    site: SiteConfig;
+    /** Markdown processing configuration */
+    markdown?: {
+        /** Array of plugins to load - each item can be a string (plugin name) or [string, options] tuple */
+        plugins?: (string | [string, unknown])[];
+        /** Function to configure the MarkdownIt instance */
+        configure?: (md: MarkdownIt) => void;
+    };
+    /** Eta template engine configuration */
+    eta?: {
+        /** Custom template filters */
+        filters?: Record<string, (x: unknown) => unknown>;
+    };
+    /** Incremental Static Generation configuration */
+    isg?: import('./isg.js').ISGConfig;
+    /** Development server configuration */
+    dev?: {
+        /** Port for development server (default: 3000) */
+        port?: number;
+        /** Host for development server (default: 'localhost') */
+        host?: string;
+        /** Whether to open browser automatically (default: false) */
+        open?: boolean;
+    };
+    /** Build lifecycle hooks */
+    hooks?: BuildHooks;
+}
+/**
+ * Build context passed to build lifecycle hooks.
+ * Contains the full configuration and all loaded pages.
+ *
+ * @example
+ * ```typescript
+ * const buildHook = async (ctx: BuildContext) => {
+ *   console.log(`Building ${ctx.pages.length} pages`);
+ *   console.log(`Output directory: ${ctx.config.outDir}`);
+ * };
+ * ```
+ */
+export interface BuildContext {
+    /** The resolved Stati configuration */
+    config: StatiConfig;
+    /** Array of all loaded page models */
+    pages: import('./content.js').PageModel[];
+}
+/**
+ * Page context passed to page-specific lifecycle hooks.
+ * Contains the current page being processed and site configuration.
+ *
+ * @example
+ * ```typescript
+ * const pageHook = async (ctx: PageContext) => {
+ *   console.log(`Rendering page: ${ctx.page.slug}`);
+ *   // Modify page content or metadata
+ *   ctx.page.frontMatter.customField = 'processed';
+ * };
+ * ```
+ */
+export interface PageContext {
+    /** The page model being processed */
+    page: import('./content.js').PageModel;
+    /** The resolved Stati configuration */
+    config: StatiConfig;
+}
+/**
+ * Build lifecycle hooks for customizing the site generation process.
+ * Allows developers to inject custom logic at various stages of the build.
+ *
+ * @example
+ * ```typescript
+ * const hooks: BuildHooks = {
+ *   beforeAll: async (ctx) => {
+ *     console.log('Starting build...');
+ *   },
+ *   beforeRender: async (ctx) => {
+ *     // Add custom data to page context
+ *     ctx.page.frontMatter.buildTime = new Date().toISOString();
+ *   },
+ *   afterAll: async (ctx) => {
+ *     console.log(`Build complete! Generated ${ctx.pages.length} pages.`);
+ *   }
+ * };
+ * ```
+ */
+export interface BuildHooks {
+    /** Called before starting the build process */
+    beforeAll?: (ctx: BuildContext) => Promise<void> | void;
+    /** Called after completing the build process */
+    afterAll?: (ctx: BuildContext) => Promise<void> | void;
+    /** Called before rendering each individual page */
+    beforeRender?: (ctx: PageContext) => Promise<void> | void;
+    /** Called after rendering each individual page */
+    afterRender?: (ctx: PageContext) => Promise<void> | void;
+}
+/**
+ * Statistics collected during the build process.
+ * Provides useful metrics about the site generation.
+ *
+ * @example
+ * ```typescript
+ * const stats: BuildStats = {
+ *   totalPages: 15,
+ *   assetsCount: 8,
+ *   buildTimeMs: 1250,
+ *   outputSizeBytes: 2048576,
+ *   cacheHits: 5,
+ *   cacheMisses: 10
+ * };
+ * ```
+ */
+export interface BuildStats {
+    /** Total number of pages processed */
+    totalPages: number;
+    /** Number of static assets copied */
+    assetsCount: number;
+    /** Total build time in milliseconds */
+    buildTimeMs: number;
+    /** Total size of output directory in bytes */
+    outputSizeBytes: number;
+    /** Number of cache hits (if caching enabled) */
+    cacheHits?: number;
+    /** Number of cache misses (if caching enabled) */
+    cacheMisses?: number;
+}
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/types/config.ts"],"names":[],"mappings":"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"}

package/dist/types/config.js

@@ -0,0 +1 @@
+export {};

package/dist/types/content.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Content related type definitions
+ */
+/**
+ * Front matter metadata extracted from content files.
+ * Contains page-specific configuration and metadata in YAML format.
+ *
+ * @example
+ * ```typescript
+ * const frontMatter: FrontMatter = {
+ *   title: 'Getting Started with Stati',
+ *   description: 'A comprehensive guide to static site generation',
+ *   tags: ['tutorial', 'documentation'],
+ *   layout: 'post',
+ *   order: 1,
+ *   publishedAt: '2024-01-01',
+ *   ttlSeconds: 3600,
+ *   draft: false
+ * };
+ * ```
+ */
+export interface FrontMatter {
+    /** Page title for SEO and display */
+    title?: string;
+    /** Page description for SEO and meta tags */
+    description?: string;
+    /** Array of tags for categorization */
+    tags?: readonly string[];
+    /** Template layout to use for rendering */
+    layout?: string;
+    /** Numeric order for sorting (useful for navigation) */
+    order?: number;
+    /** Publication date as ISO string */
+    publishedAt?: string;
+    /** Custom cache TTL in seconds (overrides global ISG settings) */
+    ttlSeconds?: number;
+    /** Custom max age cap in days (overrides global ISG settings) */
+    maxAgeCapDays?: number;
+    /** Whether the page is a draft (excludes from build) */
+    draft?: boolean;
+    /** Additional custom properties */
+    [key: string]: unknown;
+}
+/**
+ * Represents a single page in the static site.
+ * Contains all metadata, content, and URL information for a page.
+ *
+ * @example
+ * ```typescript
+ * const page: PageModel = {
+ *   slug: 'my-first-post',
+ *   url: '/blog/my-first-post',
+ *   sourcePath: '/content/blog/my-first-post.md',
+ *   frontMatter: {
+ *     title: 'My First Post',
+ *     tags: ['intro', 'blog']
+ *   },
+ *   content: '<p>Hello world!</p>',
+ *   publishedAt: new Date('2024-01-01')
+ * };
+ * ```
+ */
+export interface PageModel {
+    /** URL-friendly identifier for the page */
+    slug: string;
+    /** Full URL path for the page */
+    url: string;
+    /** Absolute path to the source content file */
+    sourcePath: string;
+    /** Parsed front matter metadata */
+    frontMatter: FrontMatter;
+    /** Rendered HTML content */
+    content: string;
+    /** Publication date (parsed from front matter or file stats) */
+    publishedAt?: Date;
+}
+/**
+ * Collection aggregation data available to index page templates.
+ * Provides access to child pages and collection metadata for content listing.
+ */
+export interface CollectionData {
+    /** All pages in the current collection */
+    pages: PageModel[];
+    /** Direct child pages of the collection */
+    children: PageModel[];
+    /** Recent pages sorted by publishedAt (most recent first) */
+    recentPages: PageModel[];
+    /** Pages grouped by tags for aggregation */
+    pagesByTag: Record<string, PageModel[]>;
+    /** Collection metadata */
+    metadata: {
+        /** Total number of pages in collection */
+        totalPages: number;
+        /** Whether collection has child pages */
+        hasChildren: boolean;
+        /** Path of the collection */
+        collectionPath: string;
+        /** Name of the collection (derived from path) */
+        collectionName: string;
+    };
+}
+/**
+ * Template rendering context passed to Eta layouts.
+ * Contains all data available to templates during rendering.
+ */
+export interface TemplateContext {
+    /** Site configuration and metadata */
+    site: import('./config.js').SiteConfig;
+    /** Current page data including frontmatter and content */
+    page: {
+        path: string;
+        content: string;
+        [key: string]: unknown;
+    };
+    /** Rendered markdown content */
+    content: string;
+    /** Site navigation tree */
+    navigation: import('./navigation.js').NavNode[];
+    /** Discovered partials from underscore folders in hierarchy */
+    partials: Record<string, string>;
+    /** Collection data for index pages (only available on collection index pages) */
+    collection?: CollectionData;
+}
+//# sourceMappingURL=content.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../src/types/content.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,WAAW;IAC1B,qCAAqC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uCAAuC;IACvC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wDAAwD;IACxD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iEAAiE;IACjE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wDAAwD;IACxD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,mCAAmC;IACnC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,SAAS;IACxB,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,iCAAiC;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,mCAAmC;IACnC,WAAW,EAAE,WAAW,CAAC;IACzB,4BAA4B;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,WAAW,CAAC,EAAE,IAAI,CAAC;CACpB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,0CAA0C;IAC1C,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,2CAA2C;IAC3C,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,6DAA6D;IAC7D,WAAW,EAAE,SAAS,EAAE,CAAC;IACzB,4CAA4C;IAC5C,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IACxC,0BAA0B;IAC1B,QAAQ,EAAE;QACR,0CAA0C;QAC1C,UAAU,EAAE,MAAM,CAAC;QACnB,yCAAyC;QACzC,WAAW,EAAE,OAAO,CAAC;QACrB,6BAA6B;QAC7B,cAAc,EAAE,MAAM,CAAC;QACvB,iDAAiD;QACjD,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;CACH;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,sCAAsC;IACtC,IAAI,EAAE,OAAO,aAAa,EAAE,UAAU,CAAC;IACvC,0DAA0D;IAC1D,IAAI,EAAE;QACJ,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;IACF,gCAAgC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,2BAA2B;IAC3B,UAAU,EAAE,OAAO,iBAAiB,EAAE,OAAO,EAAE,CAAC;IAChD,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,iFAAiF;IACjF,UAAU,CAAC,EAAE,cAAc,CAAC;CAC7B"}

package/dist/types/content.js

@@ -0,0 +1,4 @@
+/**
+ * Content related type definitions
+ */
+export {};