@stati/core 1.3.0 → 1.3.2

package/dist/core/utils/partials.js

@@ -0,0 +1,85 @@
+// dedup: partials scanning centralized in utils/partials.ts
+import { join, dirname, relative, basename, posix } from 'path';
+import glob from 'fast-glob';
+import { resolveSrcDir } from './paths.js';
+/**
+ * Scan underscore folders from root to the page's directory for .eta partials.
+ * Returns structured entries usable by both renderer and ISG deps.
+ */
+export async function scanPartialsHierarchy(pageRelativePath, config) {
+    const srcDir = resolveSrcDir(config);
+    const entries = [];
+    const dirsToScan = buildDirsToScan(pageRelativePath);
+    for (const dir of dirsToScan) {
+        const searchDir = dir ? join(srcDir, dir) : srcDir;
+        const normalizedSearchDir = searchDir.replace(/\\/g, '/');
+        const pattern = posix.join(normalizedSearchDir, '_*/**/*.eta');
+        try {
+            const files = (await glob(pattern, { absolute: true }));
+            for (const file of files) {
+                entries.push({
+                    name: basename(file, '.eta'),
+                    absPath: file,
+                    relFromSrc: relative(srcDir, file),
+                });
+            }
+        }
+        catch {
+            // Ignore errors for non-existent directories, continue scanning
+            continue;
+        }
+    }
+    return entries;
+}
+/**
+ * Build the list of directories to scan for partials from root → current page directory.
+ */
+export function buildDirsToScan(pageRelativePath) {
+    const pageDir = dirname(pageRelativePath);
+    const pathSegments = pageDir === '.' ? [] : pageDir.split(/[/\\]/);
+    const dirsToScan = [''];
+    for (let i = 0; i < pathSegments.length; i++) {
+        dirsToScan.push(pathSegments.slice(0, i + 1).join('/'));
+    }
+    return dirsToScan;
+}
+/**
+ * Renderer-focused partial discovery.
+ * Matches historical renderer behavior used by templates tests:
+ * - Only scans the current page directory (not parents)
+ * - First finds underscore folders (e.g. "_partials/")
+ * - Then finds .eta files within those folders, returning relative paths like "_partials/header.eta"
+ */
+export async function scanPartialsForRenderer(pageRelativePath, config) {
+    const srcDir = resolveSrcDir(config);
+    const pageDirRel = dirname(pageRelativePath);
+    const searchDir = pageDirRel === '.' ? srcDir : join(srcDir, pageDirRel);
+    const entries = [];
+    try {
+        // Find underscore directories relative to the page directory
+        const underscoreDirs = (await glob('_*/', { cwd: searchDir }));
+        for (const dir of underscoreDirs) {
+            try {
+                // Find .eta files inside each underscore directory
+                const etaFiles = (await glob('*.eta', { cwd: join(searchDir, dir) }));
+                for (const file of etaFiles) {
+                    const rel = join(dir, file);
+                    entries.push({
+                        name: basename(file, '.eta'),
+                        absPath: join(searchDir, rel),
+                        relFromSrc: rel,
+                    });
+                }
+            }
+            catch {
+                // Ignore per-dir errors and continue
+                continue;
+            }
+        }
+    }
+    catch {
+        // Ignore errors and return empty list (graceful)
+        return [];
+    }
+    return entries;
+}

package/dist/core/utils/paths.d.ts

@@ -0,0 +1,67 @@
+import type { StatiConfig } from '../../types/index.js';
+/**
+ * File system path resolution utilities for Stati core.
+ * Centralized utilities to ensure consistent path handling across the codebase.
+ */
+/**
+ * Resolves the absolute source directory path from configuration.
+ * @param config - Stati configuration
+ * @returns Absolute path to the source directory
+ */
+export declare function resolveSrcDir(config: StatiConfig): string;
+/**
+ * Resolves the absolute output directory path from configuration.
+ * @param config - Stati configuration
+ * @returns Absolute path to the output directory
+ */
+export declare function resolveOutDir(config: StatiConfig): string;
+/**
+ * Resolves the absolute static directory path from configuration.
+ * @param config - Stati configuration
+ * @returns Absolute path to the static directory
+ */
+export declare function resolveStaticDir(config: StatiConfig): string;
+/**
+ * Resolves the absolute cache directory path.
+ * @returns Absolute path to the .stati cache directory
+ */
+export declare function resolveCacheDir(): string;
+/**
+ * Resolves paths with defaults for development mode.
+ * @param config - Stati configuration
+ * @returns Object with all resolved directory paths with sensible defaults
+ */
+export declare function resolveDevPaths(config: StatiConfig): {
+    srcDir: string;
+    outDir: string;
+    staticDir: string;
+};
+/**
+ * Normalizes a template path for cross-platform compatibility.
+ * Ensures forward slashes are used for template engine compatibility.
+ * @param templatePath - Path to normalize
+ * @returns Normalized path with forward slashes
+ */
+export declare function normalizeTemplatePath(templatePath: string): string;
+/**
+ * Resolves a file path relative to the source directory.
+ * @param config - Stati configuration
+ * @param relativePath - Path relative to srcDir
+ * @returns Absolute path
+ */
+export declare function resolveSrcPath(config: StatiConfig, relativePath: string): string;
+/**
+ * Resolves a file path relative to the output directory.
+ * @param config - Stati configuration
+ * @param relativePath - Path relative to outDir
+ * @returns Absolute path
+ */
+export declare function resolveOutPath(config: StatiConfig, relativePath: string): string;
+/**
+ * Resolves a file path relative to the static directory.
+ * @param config - Stati configuration
+ * @param relativePath - Path relative to staticDir
+ * @returns Absolute path
+ */
+export declare function resolveStaticPath(config: StatiConfig, relativePath: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/core/utils/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/core/utils/paths.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAQxD;;;GAGG;AAEH;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAE5D;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW;;;;EAMlD;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEhF;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEhF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEnF"}

package/dist/core/utils/paths.js

@@ -0,0 +1,86 @@
+import { join } from 'path';
+import { posix } from 'path';
+import { DEFAULT_SRC_DIR, DEFAULT_OUT_DIR, DEFAULT_STATIC_DIR, CACHE_DIR_NAME, } from '../../constants.js';
+/**
+ * File system path resolution utilities for Stati core.
+ * Centralized utilities to ensure consistent path handling across the codebase.
+ */
+/**
+ * Resolves the absolute source directory path from configuration.
+ * @param config - Stati configuration
+ * @returns Absolute path to the source directory
+ */
+export function resolveSrcDir(config) {
+    return join(process.cwd(), config.srcDir);
+}
+/**
+ * Resolves the absolute output directory path from configuration.
+ * @param config - Stati configuration
+ * @returns Absolute path to the output directory
+ */
+export function resolveOutDir(config) {
+    return join(process.cwd(), config.outDir);
+}
+/**
+ * Resolves the absolute static directory path from configuration.
+ * @param config - Stati configuration
+ * @returns Absolute path to the static directory
+ */
+export function resolveStaticDir(config) {
+    return join(process.cwd(), config.staticDir);
+}
+/**
+ * Resolves the absolute cache directory path.
+ * @returns Absolute path to the .stati cache directory
+ */
+export function resolveCacheDir() {
+    return join(process.cwd(), CACHE_DIR_NAME);
+}
+/**
+ * Resolves paths with defaults for development mode.
+ * @param config - Stati configuration
+ * @returns Object with all resolved directory paths with sensible defaults
+ */
+export function resolveDevPaths(config) {
+    return {
+        srcDir: join(process.cwd(), config.srcDir || DEFAULT_SRC_DIR),
+        outDir: join(process.cwd(), config.outDir || DEFAULT_OUT_DIR),
+        staticDir: join(process.cwd(), config.staticDir || DEFAULT_STATIC_DIR),
+    };
+}
+/**
+ * Normalizes a template path for cross-platform compatibility.
+ * Ensures forward slashes are used for template engine compatibility.
+ * @param templatePath - Path to normalize
+ * @returns Normalized path with forward slashes
+ */
+export function normalizeTemplatePath(templatePath) {
+    return posix.normalize(templatePath.replace(/\\/g, '/'));
+}
+/**
+ * Resolves a file path relative to the source directory.
+ * @param config - Stati configuration
+ * @param relativePath - Path relative to srcDir
+ * @returns Absolute path
+ */
+export function resolveSrcPath(config, relativePath) {
+    return join(resolveSrcDir(config), relativePath);
+}
+/**
+ * Resolves a file path relative to the output directory.
+ * @param config - Stati configuration
+ * @param relativePath - Path relative to outDir
+ * @returns Absolute path
+ */
+export function resolveOutPath(config, relativePath) {
+    return join(resolveOutDir(config), relativePath);
+}
+/**
+ * Resolves a file path relative to the static directory.
+ * @param config - Stati configuration
+ * @param relativePath - Path relative to staticDir
+ * @returns Absolute path
+ */
+export function resolveStaticPath(config, relativePath) {
+    return join(resolveStaticDir(config), relativePath);
+}

package/dist/core/utils/template-discovery.d.ts

@@ -0,0 +1,34 @@
+import type { StatiConfig, PageModel } from '../../types/index.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 declare function isCollectionIndexPage(page: PageModel, allPages?: PageModel[]): boolean;
+/**
+ * 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 declare function discoverLayout(pagePath: string, config: StatiConfig, explicitLayout?: string, isIndexPage?: boolean): Promise<string | 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 declare function getCollectionPathForPage(pageUrl: string): string;
+//# sourceMappingURL=template-discovery.d.ts.map

package/dist/core/utils/template-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-discovery.d.ts","sourceRoot":"","sources":["../../../src/core/utils/template-discovery.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAInE;;;GAGG;AAEH;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,SAAS,EAAE,GAAG,OAAO,CAkBtF;AAED;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,WAAW,EACnB,cAAc,CAAC,EAAE,MAAM,EACvB,WAAW,CAAC,EAAE,OAAO,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAsDxB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAkBhE"}

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,7 +19,7 @@
  * 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 { InvalidationResult } from './core/invalidate.js';
@@ -27,7 +27,7 @@ export { build } from './core/build.js';
 export { createDevServer } from './core/dev.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,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,kBAAkB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAE7D"}

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;