@stati/core 1.3.1 → 1.4.0

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

@@ -1 +1 @@
-{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../src/core/templates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAM1B,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,EAAkB,MAAM,aAAa,CAAC;AAgRnF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,GAAG,CAS7D;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,WAAW,EACnB,GAAG,EAAE,GAAG,EACR,UAAU,CAAC,EAAE,OAAO,EAAE,EACtB,QAAQ,CAAC,EAAE,SAAS,EAAE,GACrB,OAAO,CAAC,MAAM,CAAC,CAkEjB"}
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../src/core/templates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAG1B,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,EAAkB,MAAM,mBAAmB,CAAC;AAiLzF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,GAAG,CAU7D;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,WAAW,EACnB,GAAG,EAAE,GAAG,EACR,UAAU,CAAC,EAAE,OAAO,EAAE,EACtB,QAAQ,CAAC,EAAE,SAAS,EAAE,GACrB,OAAO,CAAC,MAAM,CAAC,CAkEjB"}

package/dist/core/templates.js

@@ -1,43 +1,9 @@
 import { Eta } from 'eta';
-import { join, dirname, relative, basename } from 'path';
-import { posix } from 'path';
-import fse from 'fs-extra';
-const { pathExists } = fse;
+import { join, dirname, relative, basename, posix } from 'path';
 import glob from 'fast-glob';
-/**
- * Determines if the given page is an index page for a collection.
- * An 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
- * @returns True if the page is a collection index page
- */
-function isCollectionIndexPage(page, allPages) {
-    // Root index page is always a collection index
-    if (page.url === '/') {
-        return true;
-    }
-    // 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));
-}
-/**
- * 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
- */
-function getCollectionPathForPage(pageUrl) {
-    if (pageUrl === '/') {
-        return '/';
-    }
-    const pathParts = pageUrl.split('/').filter(Boolean);
-    if (pathParts.length <= 1) {
-        return '/';
-    }
-    return '/' + pathParts.slice(0, -1).join('/');
-}
+import { TEMPLATE_EXTENSION } from '../constants.js';
+import { isCollectionIndexPage, discoverLayout, getCollectionPathForPage, } from './utils/template-discovery.js';
+import { resolveSrcDir } from './utils/paths.js';
 /**
  * Groups pages by their tags for aggregation purposes.
  *
@@ -142,105 +108,62 @@ function buildCollectionData(currentPage, allPages) {
  * @returns Object mapping partial names to their file paths
  */
 async function discoverPartials(pagePath, config) {
-    const srcDir = join(process.cwd(), config.srcDir);
+    const srcDir = resolveSrcDir(config);
     const partials = {};
     // Get the directory of the current page
     const pageDir = dirname(pagePath);
     const pathSegments = pageDir === '.' ? [] : pageDir.split('/');
-    // Scan from root to current directory
-    const dirsToScan = [''];
-    for (let i = 0; i < pathSegments.length; i++) {
-        dirsToScan.push(pathSegments.slice(0, i + 1).join('/'));
+    // Scan from root to current directory (least specific first)
+    // This allows more specific partials to override less specific ones
+    const dirsToScan = [];
+    if (pathSegments.length > 0) {
+        // Add root directory first, then parent directories, then current
+        dirsToScan.push(''); // Root directory first
+        // Add directories from root to current
+        for (let i = 1; i <= pathSegments.length; i++) {
+            dirsToScan.push(pathSegments.slice(0, i).join('/'));
+        }
+    }
+    else {
+        dirsToScan.push(''); // Root directory only
     }
     for (const dir of dirsToScan) {
         const searchDir = dir ? join(srcDir, dir) : srcDir;
         // Find all underscore folders in this directory level
-        const underscoreFolders = await glob('_*/', {
-            cwd: searchDir,
+        const globPattern = join(searchDir, '_*/').replace(/\\/g, '/');
+        const underscoreFolders = await glob(globPattern, {
+            absolute: true,
             onlyDirectories: true,
         });
         // Scan each underscore folder for .eta files
-        for (const folder of underscoreFolders) {
-            const folderPath = join(searchDir, folder);
+        for (const folderPath of underscoreFolders) {
             const etaFiles = await glob('**/*.eta', {
                 cwd: folderPath,
                 absolute: false,
             });
             for (const etaFile of etaFiles) {
-                const partialName = basename(etaFile, '.eta');
+                const partialName = basename(etaFile, TEMPLATE_EXTENSION);
                 const fullPath = join(folderPath, etaFile);
+                // Get relative path from srcDir to the partial file
                 const relativePath = relative(srcDir, fullPath);
-                // Store the relative path from srcDir for Eta to find it
-                partials[partialName] = relativePath;
+                partials[partialName] = posix.normalize(relativePath);
             }
         }
     }
     return partials;
 }
-/**
- * Discovers the appropriate layout file for a given page path.
- * Implements the hierarchical layout.eta convention by searching
- * from the page's directory up to the root.
- *
- * @param pagePath - The path to the page (relative to srcDir)
- * @param config - Stati configuration
- * @param explicitLayout - Layout specified in front matter (takes precedence)
- * @param isIndexPage - Whether this is an aggregation/index page (enables index.eta lookup)
- * @returns The layout file path or null if none found
- */
-async function discoverLayout(pagePath, config, explicitLayout, isIndexPage) {
-    const srcDir = join(process.cwd(), config.srcDir);
-    // 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.eta') : join(srcDir, 'layout.eta');
-        if (await pathExists(layoutPath)) {
-            // Return relative path with forward slashes for Eta
-            const relativePath = dir ? `${dir}/layout.eta` : 'layout.eta';
-            return posix.normalize(relativePath);
-        }
-    }
-    return null;
-}
 export function createTemplateEngine(config) {
-    const templateDir = join(process.cwd(), config.srcDir);
+    const templateDir = resolveSrcDir(config);
     const eta = new Eta({
         views: templateDir,
         cache: process.env.NODE_ENV === 'production',
+        cacheFilepaths: process.env.NODE_ENV === 'production',
     });
     return eta;
 }
 export async function renderPage(page, body, config, eta, navigation, allPages) {
     // Discover partials for this page's directory hierarchy
-    const srcDir = join(process.cwd(), config.srcDir);
+    const srcDir = resolveSrcDir(config);
     const relativePath = relative(srcDir, page.sourcePath);
     const partialPaths = await discoverPartials(relativePath, config);
     // Build collection data if this is an index page and all pages are provided

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

@@ -0,0 +1,37 @@
+import fse from 'fs-extra';
+import type { WriteFileOptions } from 'fs';
+/**
+ * Safely reads a file with consistent error handling.
+ */
+export declare function readFile(filePath: string, encoding?: 'utf-8' | 'utf8'): Promise<string | null>;
+/**
+ * Safely writes content to a file with consistent error handling.
+ */
+export declare function writeFile(filePath: string, content: string, options?: WriteFileOptions): Promise<void>;
+/**
+ * Checks if a path exists with consistent error handling.
+ */
+export declare function pathExists(filePath: string): Promise<boolean>;
+/**
+ * Ensures a directory exists with consistent error handling.
+ */
+export declare function ensureDir(dirPath: string): Promise<void>;
+/**
+ * Removes a file or directory with consistent error handling.
+ */
+export declare function remove(path: string): Promise<void>;
+/**
+ * Gets file stats with consistent error handling.
+ */
+export declare function stat(filePath: string): Promise<fse.Stats>;
+/**
+ * Reads directory contents with consistent error handling.
+ */
+export declare function readdir<T extends boolean = false>(dirPath: string, options?: {
+    withFileTypes?: T;
+}): Promise<T extends true ? fse.Dirent[] : string[]>;
+/**
+ * Copies a file with consistent error handling.
+ */
+export declare function copyFile(src: string, dest: string): Promise<void>;
+//# sourceMappingURL=fs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../../src/core/utils/fs.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,UAAU,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,IAAI,CAAC;AAkD3C;;GAEG;AACH,wBAAsB,QAAQ,CAC5B,QAAQ,EAAE,MAAM,EAChB,QAAQ,GAAE,OAAO,GAAG,MAAgB,GACnC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAExB;AAED;;GAEG;AACH,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAEnE;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE9D;AAED;;GAEG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAExD;AAED;;GAEG;AACH,wBAAsB,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAE/D;AAED;;GAEG;AACH,wBAAsB,OAAO,CAAC,CAAC,SAAS,OAAO,GAAG,KAAK,EACrD,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;IAAE,aAAa,CAAC,EAAE,CAAC,CAAA;CAAE,GAC9B,OAAO,CAAC,CAAC,SAAS,IAAI,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAYnD;AAED;;GAEG;AACH,wBAAsB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEvE"}

package/dist/core/utils/fs.js

@@ -0,0 +1,86 @@
+import fse from 'fs-extra';
+const { readFile: fseReadFile, writeFile: fseWriteFile, pathExists: fsePathExists, ensureDir: fseEnsureDir, remove: fseRemove, stat: fseStat, readdir: fseReaddir, copyFile: fseCopyFile, } = fse;
+/**
+ * Wraps fs-extra operations with consistent error handling.
+ */
+async function wrapFsOperation(operation, fsCall, path) {
+    try {
+        return await fsCall;
+    }
+    catch (error) {
+        const nodeError = error;
+        throw new Error(`Failed to ${operation} ${path}: ${nodeError.message}`);
+    }
+}
+/**
+ * Wraps fs-extra operations that should return null on ENOENT.
+ */
+async function wrapFsOperationNullable(operation, fsCall, path) {
+    try {
+        return await fsCall;
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code === 'ENOENT') {
+            return null; // File doesn't exist
+        }
+        throw new Error(`Failed to ${operation} ${path}: ${nodeError.message}`);
+    }
+}
+/**
+ * Safely reads a file with consistent error handling.
+ */
+export async function readFile(filePath, encoding = 'utf-8') {
+    return wrapFsOperationNullable('read file', fseReadFile(filePath, encoding), filePath);
+}
+/**
+ * Safely writes content to a file with consistent error handling.
+ */
+export async function writeFile(filePath, content, options) {
+    return wrapFsOperation('write file', fseWriteFile(filePath, content, options), filePath);
+}
+/**
+ * Checks if a path exists with consistent error handling.
+ */
+export async function pathExists(filePath) {
+    return wrapFsOperation('check path', fsePathExists(filePath), filePath);
+}
+/**
+ * Ensures a directory exists with consistent error handling.
+ */
+export async function ensureDir(dirPath) {
+    return wrapFsOperation('create directory', fseEnsureDir(dirPath), dirPath);
+}
+/**
+ * Removes a file or directory with consistent error handling.
+ */
+export async function remove(path) {
+    return wrapFsOperation('remove', fseRemove(path), path);
+}
+/**
+ * Gets file stats with consistent error handling.
+ */
+export async function stat(filePath) {
+    return wrapFsOperation('get stats for', fseStat(filePath), filePath);
+}
+/**
+ * Reads directory contents with consistent error handling.
+ */
+export async function readdir(dirPath, options) {
+    try {
+        if (options?.withFileTypes) {
+            return (await fseReaddir(dirPath, { withFileTypes: true }));
+        }
+        return (await fseReaddir(dirPath));
+    }
+    catch (error) {
+        const nodeError = error;
+        throw new Error(`Failed to read directory ${dirPath}: ${nodeError.message}`);
+    }
+}
+/**
+ * Copies a file with consistent error handling.
+ */
+export async function copyFile(src, dest) {
+    return wrapFsOperation('copy', fseCopyFile(src, dest), `${src} to ${dest}`);
+}

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

@@ -0,0 +1,24 @@
+import type { StatiConfig } from '../../types.js';
+export interface PartialEntry {
+    name: string;
+    absPath: string;
+    relFromSrc: string;
+}
+/**
+ * Scan underscore folders from root to the page's directory for .eta partials.
+ * Returns structured entries usable by both renderer and ISG deps.
+ */
+export declare function scanPartialsHierarchy(pageRelativePath: string, config: StatiConfig): Promise<PartialEntry[]>;
+/**
+ * Build the list of directories to scan for partials from root → current page directory.
+ */
+export declare function buildDirsToScan(pageRelativePath: string): string[];
+/**
+ * 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 declare function scanPartialsForRenderer(pageRelativePath: string, config: StatiConfig): Promise<PartialEntry[]>;
+//# sourceMappingURL=partials.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"partials.d.ts","sourceRoot":"","sources":["../../../src/core/utils/partials.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAGlD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,gBAAgB,EAAE,MAAM,EACxB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,YAAY,EAAE,CAAC,CA2BzB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,EAAE,CASlE;AAED;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC3C,gBAAgB,EAAE,MAAM,EACxB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,YAAY,EAAE,CAAC,CAkCzB"}

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"}