@stati/core 1.3.0 → 1.3.2

package/dist/core/dev.js

@@ -7,28 +7,12 @@ import chokidar from 'chokidar';
 import { build } from './build.js';
 import { loadConfig } from '../config/loader.js';
 import { loadCacheManifest, saveCacheManifest } from './isg/manifest.js';
+import { resolveDevPaths, resolveCacheDir } from './utils/paths.js';
+import { DEFAULT_DEV_PORT, DEFAULT_DEV_HOST, TEMPLATE_EXTENSION } from '../constants.js';
 /**
- * Creates and configures a development server with live reload functionality.
- *
- * @param options - Development server configuration options
- * @returns Promise resolving to a DevServer instance
+ * Loads and validates configuration for the dev server.
  */
-export async function createDevServer(options = {}) {
-    const { port = 3000, host = 'localhost', open = false, configPath, logger = {
-        info: (msg) => console.log(msg),
-        success: (msg) => console.log(msg),
-        error: (msg) => console.error(msg),
-        warning: (msg) => console.warn(msg),
-        building: (msg) => console.log(msg),
-        processing: (msg) => console.log(msg),
-        stats: (msg) => console.log(msg),
-    }, } = options;
-    const url = `http://${host}:${port}`;
-    let httpServer = null;
-    let wsServer = null;
-    let watcher = null;
-    let config;
-    let isBuilding = false;
+async function loadDevConfig(configPath, logger) {
     // Load configuration
     try {
         if (configPath) {
@@ -36,124 +20,122 @@ export async function createDevServer(options = {}) {
             // This is a limitation of the current loadConfig implementation
             logger.info?.(`Loading config from: ${configPath}`);
         }
-        config = await loadConfig(process.cwd());
+        const config = await loadConfig(process.cwd());
+        const { outDir, srcDir, staticDir } = resolveDevPaths(config);
+        return { config, outDir, srcDir, staticDir };
     }
     catch (error) {
         logger.error?.(`Failed to load config: ${error instanceof Error ? error.message : String(error)}`);
         throw error;
     }
-    const outDir = join(process.cwd(), config.outDir || 'dist');
-    const srcDir = join(process.cwd(), config.srcDir || 'site');
-    const staticDir = join(process.cwd(), config.staticDir || 'public');
-    /**
-     * Performs an initial build to ensure dist/ exists
-     */
-    async function initialBuild() {
-        try {
+}
+/**
+ * Performs an initial build to ensure dist/ exists
+ */
+async function performInitialBuild(configPath, logger) {
+    try {
+        await build({
+            logger,
+            force: false,
+            clean: false,
+            ...(configPath && { configPath }),
+        });
+    }
+    catch (error) {
+        logger.error?.(`Initial build failed: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}
+/**
+ * Performs incremental rebuild when files change, using ISG logic for smart rebuilds
+ */
+async function performIncrementalRebuild(changedPath, configPath, logger, wsServer, isBuildingRef) {
+    if (isBuildingRef.value) {
+        logger.info?.('Build in progress, skipping...');
+        return;
+    }
+    isBuildingRef.value = true;
+    const startTime = Date.now();
+    // Create a quiet logger for dev builds that suppresses verbose output
+    const devLogger = {
+        info: () => { }, // Suppress info messages
+        success: () => { }, // Suppress success messages
+        error: logger.error || (() => { }),
+        warning: logger.warning || (() => { }),
+        building: () => { }, // Suppress building messages
+        processing: () => { }, // Suppress processing messages
+        stats: () => { }, // Suppress stats messages
+    };
+    try {
+        const relativePath = changedPath
+            .replace(process.cwd(), '')
+            .replace(/\\/g, '/')
+            .replace(/^\//, '');
+        // Check if the changed file is a template/partial
+        if (changedPath.endsWith(TEMPLATE_EXTENSION) || changedPath.includes('_partials')) {
+            await handleTemplateChange(changedPath, configPath, devLogger);
+        }
+        else {
+            // Content or static file changed - use normal rebuild
             await build({
-                logger,
+                logger: devLogger,
                 force: false,
                 clean: false,
                 ...(configPath && { configPath }),
             });
         }
-        catch (error) {
-            logger.error?.(`Initial build failed: ${error instanceof Error ? error.message : String(error)}`);
-            throw error;
+        // Notify all connected clients to reload
+        if (wsServer) {
+            wsServer.clients.forEach((client) => {
+                const ws = client;
+                if (ws.readyState === 1) {
+                    // WebSocket.OPEN
+                    ws.send(JSON.stringify({ type: 'reload' }));
+                }
+            });
         }
+        const duration = Date.now() - startTime;
+        logger.info?.(`⚡ ${relativePath} rebuilt in ${duration}ms`);
     }
-    /**
-     * Performs incremental rebuild when files change, using ISG logic for smart rebuilds
-     */
-    async function incrementalRebuild(changedPath) {
-        if (isBuilding) {
-            logger.info?.('⏳ Build in progress, skipping...');
+    catch (error) {
+        const duration = Date.now() - startTime;
+        logger.error?.(`❌ Rebuild failed after ${duration}ms: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    finally {
+        isBuildingRef.value = false;
+    }
+}
+/**
+ * Handles template/partial file changes by invalidating affected pages
+ */
+async function handleTemplateChange(templatePath, configPath, logger) {
+    const cacheDir = resolveCacheDir();
+    try {
+        // Load existing cache manifest
+        const cacheManifest = await loadCacheManifest(cacheDir);
+        if (!cacheManifest) {
+            // No cache exists, perform full rebuild
+            await build({
+                logger,
+                force: false,
+                clean: false,
+                ...(configPath && { configPath }),
+            });
             return;
         }
-        isBuilding = true;
-        try {
-            // Check if the changed file is a template/partial
-            if (changedPath.endsWith('.eta') || changedPath.includes('_partials')) {
-                logger.info?.(`🎨 Template changed: ${changedPath}`);
-                await handleTemplateChange(changedPath);
-            }
-            else {
-                // Content or static file changed - use normal rebuild
-                logger.info?.(`📄 Content changed: ${changedPath}`);
-                await build({
-                    logger,
-                    force: false,
-                    clean: false,
-                    ...(configPath && { configPath }),
-                });
-            }
-            // Notify all connected clients to reload
-            if (wsServer) {
-                wsServer.clients.forEach((client) => {
-                    const ws = client;
-                    if (ws.readyState === 1) {
-                        // WebSocket.OPEN
-                        ws.send(JSON.stringify({ type: 'reload' }));
-                    }
-                });
+        // Find pages that depend on this template
+        const affectedPages = [];
+        for (const [pagePath, entry] of Object.entries(cacheManifest.entries)) {
+            if (entry.deps.some((dep) => dep.includes(posix.normalize(templatePath.replace(/\\/g, '/'))))) {
+                affectedPages.push(pagePath);
+                // Remove from cache to force rebuild
+                delete cacheManifest.entries[pagePath];
             }
-            logger.success?.('Rebuild complete');
-        }
-        catch (error) {
-            logger.error?.(`Rebuild failed: ${error instanceof Error ? error.message : String(error)}`);
         }
-        finally {
-            isBuilding = false;
-        }
-    }
-    /**
-     * Handles template/partial file changes by invalidating affected pages
-     */
-    async function handleTemplateChange(templatePath) {
-        const cacheDir = join(process.cwd(), '.stati');
-        try {
-            // Load existing cache manifest
-            let cacheManifest = await loadCacheManifest(cacheDir);
-            if (!cacheManifest) {
-                // No cache exists, perform full rebuild
-                logger.info?.('No cache found, performing full rebuild...');
-                await build({
-                    logger,
-                    force: false,
-                    clean: false,
-                    ...(configPath && { configPath }),
-                });
-                return;
-            }
-            // Find pages that depend on this template
-            const affectedPages = [];
-            for (const [pagePath, entry] of Object.entries(cacheManifest.entries)) {
-                if (entry.deps.some((dep) => dep.includes(posix.normalize(templatePath.replace(/\\/g, '/'))))) {
-                    affectedPages.push(pagePath);
-                    // Remove from cache to force rebuild
-                    delete cacheManifest.entries[pagePath];
-                }
-            }
-            if (affectedPages.length > 0) {
-                logger.info?.(`🎯 Invalidating ${affectedPages.length} affected pages:`);
-                affectedPages.forEach((page) => logger.info?.(`   📄 ${page}`));
-                // Save updated cache manifest
-                await saveCacheManifest(cacheDir, cacheManifest);
-                // Perform incremental rebuild (only affected pages will be rebuilt)
-                await build({
-                    logger,
-                    force: false,
-                    clean: false,
-                    ...(configPath && { configPath }),
-                });
-            }
-            else {
-                logger.info?.('ℹ️  No pages affected by template change');
-            }
-        }
-        catch (error) {
-            logger.warning?.(`Template dependency analysis failed, performing full rebuild: ${error instanceof Error ? error.message : String(error)}`);
-            // Fallback to full rebuild
+        if (affectedPages.length > 0) {
+            // Save updated cache manifest
+            await saveCacheManifest(cacheDir, cacheManifest);
+            // Perform incremental rebuild (only affected pages will be rebuilt)
             await build({
                 logger,
                 force: false,
@@ -162,6 +144,33 @@ export async function createDevServer(options = {}) {
             });
         }
     }
+    catch {
+        // Fallback to full rebuild
+        await build({
+            logger,
+            force: false,
+            clean: false,
+            ...(configPath && { configPath }),
+        });
+    }
+}
+export async function createDevServer(options = {}) {
+    const { port = DEFAULT_DEV_PORT, host = DEFAULT_DEV_HOST, open = false, configPath, logger = {
+        info: (msg) => console.log(msg),
+        success: (msg) => console.log(msg),
+        error: (msg) => console.error(msg),
+        warning: (msg) => console.warn(msg),
+        building: (msg) => console.log(msg),
+        processing: (msg) => console.log(msg),
+        stats: (msg) => console.log(msg),
+    }, } = options;
+    const url = `http://${host}:${port}`;
+    let httpServer = null;
+    let wsServer = null;
+    let watcher = null;
+    const isBuildingRef = { value: false };
+    // Load configuration
+    const { config: _config, outDir, srcDir, staticDir } = await loadDevConfig(configPath, logger);
     /**
      * Gets MIME type for a file based on its extension
      */
@@ -272,7 +281,7 @@ export async function createDevServer(options = {}) {
         url,
         async start() {
             // Perform initial build
-            await initialBuild();
+            await performInitialBuild(configPath, logger);
             // Create HTTP server
             httpServer = createServer(async (req, res) => {
                 const requestPath = req.url || '/';
@@ -302,7 +311,7 @@ export async function createDevServer(options = {}) {
                 path: '/__ws',
             });
             wsServer.on('connection', (ws) => {
-                logger.info?.('🔗 Browser connected for live reload');
+                logger.info?.('Browser connected for live reload');
                 const websocket = ws;
                 websocket.on('close', () => {
                     logger.info?.('Browser disconnected from live reload');
@@ -325,13 +334,13 @@ export async function createDevServer(options = {}) {
                 ignoreInitial: true,
             });
             watcher.on('change', (path) => {
-                void incrementalRebuild(path);
+                void performIncrementalRebuild(path, configPath, logger, wsServer, isBuildingRef);
             });
             watcher.on('add', (path) => {
-                void incrementalRebuild(path);
+                void performIncrementalRebuild(path, configPath, logger, wsServer, isBuildingRef);
             });
             watcher.on('unlink', (path) => {
-                void incrementalRebuild(path);
+                void performIncrementalRebuild(path, configPath, logger, wsServer, isBuildingRef);
             });
             logger.success?.(`Dev server running at ${url}`);
             logger.info?.(`\nServing from:`);

package/dist/core/invalidate.d.ts

@@ -1,4 +1,4 @@
-import type { CacheEntry } from '../types.js';
+import type { CacheEntry } from '../types/index.js';
 /**
  * Invalidation result containing affected cache entries.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"invalidate.d.ts","sourceRoot":"","sources":["../../src/core/invalidate.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,gBAAgB,EAAE,MAAM,CAAC;IACzB,iCAAiC;IACjC,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,2CAA2C;IAC3C,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAkC9D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAkC9F;AAiLD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAoD5E"}
+{"version":3,"file":"invalidate.d.ts","sourceRoot":"","sources":["../../src/core/invalidate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,gBAAgB,EAAE,MAAM,CAAC;IACzB,iCAAiC;IACjC,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,2CAA2C;IAC3C,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAkC9D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAkC9F;AAiLD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAoD5E"}

package/dist/core/invalidate.js

@@ -1,5 +1,5 @@
-import { join } from 'path';
 import { loadCacheManifest, saveCacheManifest } from './isg/manifest.js';
+import { resolveCacheDir } from './utils/paths.js';
 /**
  * Parses an invalidation query string into individual query terms.
  * Supports space-separated values and quoted strings.
@@ -281,9 +281,9 @@ function matchesAge(entry, ageValue) {
  * ```
  */
 export async function invalidate(query) {
-    const cacheDir = join(process.cwd(), '.stati');
+    const cacheDir = resolveCacheDir();
     // Load existing cache manifest
-    let cacheManifest = await loadCacheManifest(cacheDir);
+    const cacheManifest = await loadCacheManifest(cacheDir);
     if (!cacheManifest) {
         // No cache to invalidate
         return {

package/dist/core/isg/build-lock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-lock.d.ts","sourceRoot":"","sources":["../../../src/core/isg/build-lock.ts"],"names":[],"mappings":"AAYA;;GAEG;AACH,UAAU,SAAS;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAS;gBAEb,QAAQ,EAAE,MAAM;IAI5B;;;;;;;;;;;;;;;;;;;OAmBG;IACG,WAAW,CAAC,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAoDrF;;;;;;;OAOG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAqBlC;;;;;;;;;;;OAWG;IACG,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;IAiBpC;;;;OAIG;IACG,WAAW,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAY9C;;;OAGG;YACW,eAAe;IAQ7B;;OAEG;YACW,cAAc;IAc5B;;OAEG;YACW,YAAY;IAS1B;;OAEG;YACW,gBAAgB;IAY9B;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;OAEG;IACH,OAAO,CAAC,KAAK;CAGd;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACzB,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAClD,OAAO,CAAC,CAAC,CAAC,CASZ"}
+{"version":3,"file":"build-lock.d.ts","sourceRoot":"","sources":["../../../src/core/isg/build-lock.ts"],"names":[],"mappings":"AAWA;;GAEG;AACH,UAAU,SAAS;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAS;gBAEb,QAAQ,EAAE,MAAM;IAI5B;;;;;;;;;;;;;;;;;;;OAmBG;IACG,WAAW,CAAC,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAoDrF;;;;;;;OAOG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAqBlC;;;;;;;;;;;OAWG;IACG,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;IAiBpC;;;;OAIG;IACG,WAAW,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAY9C;;;OAGG;YACW,eAAe;IAQ7B;;OAEG;YACW,cAAc;IAc5B;;OAEG;YACW,YAAY;IAY1B;;OAEG;YACW,gBAAgB;IAY9B;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;OAEG;IACH,OAAO,CAAC,KAAK;CAGd;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACzB,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAClD,OAAO,CAAC,CAAC,CAAC,CASZ"}

package/dist/core/isg/build-lock.js

@@ -1,5 +1,4 @@
-import fse from 'fs-extra';
-const { writeFile, readFile, pathExists, remove, ensureDir } = fse;
+import { writeFile, readFile, pathExists, remove, ensureDir } from '../utils/fs.js';
 import { join, dirname } from 'path';
 import { hostname } from 'os';
 /**
@@ -178,6 +177,9 @@ export class BuildLockManager {
     async readLockFile() {
         try {
             const content = await readFile(this.lockPath, 'utf-8');
+            if (!content) {
+                return null;
+            }
             return JSON.parse(content);
         }
         catch {

package/dist/core/isg/builder.d.ts

@@ -1,4 +1,4 @@
-import type { PageModel, CacheEntry, StatiConfig } from '../../types.js';
+import type { PageModel, CacheEntry, StatiConfig } from '../../types/index.js';
 /**
  * Determines if a page should be rebuilt based on ISG logic.
  * Checks content changes, dependency changes, TTL expiration, and freeze status.

package/dist/core/isg/builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../src/core/isg/builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAmEzE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,MAAM,EAAE,WAAW,EACnB,GAAG,EAAE,IAAI,GACR,OAAO,CAAC,OAAO,CAAC,CAgKlB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,IAAI,GACf,OAAO,CAAC,UAAU,CAAC,CA2ErB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,IAAI,GACf,OAAO,CAAC,UAAU,CAAC,CAUrB"}
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../src/core/isg/builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAmE/E;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,MAAM,EAAE,WAAW,EACnB,GAAG,EAAE,IAAI,GACR,OAAO,CAAC,OAAO,CAAC,CAgKlB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,IAAI,GACf,OAAO,CAAC,UAAU,CAAC,CA2ErB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,IAAI,GACf,OAAO,CAAC,UAAU,CAAC,CAUrB"}

package/dist/core/isg/deps.d.ts

@@ -1,4 +1,4 @@
-import type { PageModel, StatiConfig } from '../../types.js';
+import type { PageModel, StatiConfig } from '../../types/index.js';
 /**
  * Error thrown when a circular dependency is detected in templates.
  */

package/dist/core/isg/deps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../../../src/core/isg/deps.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7D;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;aAE9B,eAAe,EAAE,MAAM,EAAE;gBAAzB,eAAe,EAAE,MAAM,EAAE,EACzC,OAAO,EAAE,MAAM;CAKlB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC,CAoCnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC,CAiDnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CASxB"}
+{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../../../src/core/isg/deps.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAKnE;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;aAE9B,eAAe,EAAE,MAAM,EAAE;gBAAzB,eAAe,EAAE,MAAM,EAAE,EACzC,OAAO,EAAE,MAAM;CAKlB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC,CAoCnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC,CAiDnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CASxB"}

package/dist/core/isg/deps.js

@@ -1,7 +1,9 @@
 import { join, dirname, relative, posix } from 'path';
-import fse from 'fs-extra';
-const { pathExists, readFile } = fse;
+import { pathExists, readFile } from '../utils/fs.js';
 import glob from 'fast-glob';
+import { TEMPLATE_EXTENSION } from '../../constants.js';
+import { isCollectionIndexPage, discoverLayout } from '../utils/template-discovery.js';
+import { resolveSrcDir } from '../utils/paths.js';
 /**
  * Error thrown when a circular dependency is detected in templates.
  */
@@ -42,7 +44,7 @@ export async function trackTemplateDependencies(page, config) {
         return [];
     }
     const deps = [];
-    const srcDir = join(process.cwd(), config.srcDir);
+    const srcDir = resolveSrcDir(config);
     const relativePath = relative(srcDir, page.sourcePath);
     // Track dependencies with circular detection
     const visited = new Set();
@@ -80,7 +82,7 @@ export async function findPartialDependencies(pagePath, config) {
         return [];
     }
     const deps = [];
-    const srcDir = join(process.cwd(), config.srcDir);
+    const srcDir = resolveSrcDir(config);
     // Get the directory of the current page
     const pageDir = dirname(pagePath);
     const pathSegments = pageDir === '.' ? [] : pageDir.split(/[/\\]/);
@@ -135,71 +137,13 @@ export async function findPartialDependencies(pagePath, config) {
  * ```
  */
 export async function resolveTemplatePath(layout, config) {
-    const srcDir = join(process.cwd(), config.srcDir);
+    const srcDir = resolveSrcDir(config);
     const layoutPath = join(srcDir, `${layout}.eta`);
     if (await pathExists(layoutPath)) {
         return layoutPath;
     }
     return null;
 }
-/**
- * Helper function to determine if a page is a collection index page.
- * Duplicated from templates.ts to avoid circular dependencies.
- */
-function isCollectionIndexPage(page) {
-    // This is a simplified version - in a real implementation,
-    // we'd need access to all pages to determine this properly.
-    // For now, we'll assume any page ending in /index or at root is a collection page.
-    return page.url === '/' || page.url.endsWith('/index') || page.slug === 'index';
-}
-/**
- * Helper function to discover layout files.
- * Duplicated from templates.ts to avoid circular dependencies.
- */
-async function discoverLayout(pagePath, config, explicitLayout, isIndexPage) {
-    // Early return if required config values are missing
-    if (!config.srcDir) {
-        return null;
-    }
-    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(/[/\\]/);
-    // 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)) {
-                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)) {
-            const relativePath = dir ? `${dir}/layout.eta` : 'layout.eta';
-            return posix.normalize(relativePath);
-        }
-    }
-    return null;
-}
 /**
  * Detects circular dependencies in template includes/extends.
  * Uses DFS to traverse the dependency graph and detect cycles.
@@ -233,6 +177,9 @@ async function detectCircularDependencies(templatePath, srcDir, visited, current
     try {
         // Read template content to find includes/extends
         const content = await readFile(templatePath, 'utf-8');
+        if (!content) {
+            return; // Skip if file doesn't exist
+        }
         const dependencies = await parseTemplateDependencies(content, templatePath, srcDir);
         // Recursively check dependencies
         for (const depPath of dependencies) {
@@ -264,6 +211,7 @@ async function detectCircularDependencies(templatePath, srcDir, visited, current
  */
 async function parseTemplateDependencies(content, templatePath, srcDir) {
     const dependencies = [];
+    const templateDir = dirname(templatePath);
     // Look for Eta include patterns: <%~ include('template') %>
     const includePatterns = [
         /<%[~-]?\s*include\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g,
@@ -274,7 +222,7 @@ async function parseTemplateDependencies(content, templatePath, srcDir) {
         while ((match = pattern.exec(content)) !== null) {
             const includePath = match[1];
             if (includePath) {
-                const resolvedPath = await resolveTemplatePathInternal(includePath, srcDir);
+                const resolvedPath = await resolveTemplatePathInternal(includePath, srcDir, templateDir);
                 if (resolvedPath) {
                     dependencies.push(resolvedPath);
                 }
@@ -291,7 +239,7 @@ async function parseTemplateDependencies(content, templatePath, srcDir) {
         while ((match = pattern.exec(content)) !== null) {
             const layoutPath = match[1];
             if (layoutPath) {
-                const resolvedPath = await resolveTemplatePathInternal(layoutPath, srcDir);
+                const resolvedPath = await resolveTemplatePathInternal(layoutPath, srcDir, templateDir);
                 if (resolvedPath) {
                     dependencies.push(resolvedPath);
                 }
@@ -306,26 +254,59 @@ async function parseTemplateDependencies(content, templatePath, srcDir) {
  *
  * @param templateRef - Template reference from include/layout statement
  * @param srcDir - Source directory for resolving paths
+ * @param currentDir - Current directory for hierarchical search (optional)
  * @returns Absolute path to template file, or null if not found
  */
-async function resolveTemplatePathInternal(templateRef, srcDir) {
-    // Add .eta extension if not present
-    const templateName = templateRef.endsWith('.eta') ? templateRef : `${templateRef}.eta`;
+async function resolveTemplatePathInternal(templateRef, srcDir, currentDir) {
+    const templateName = templateRef.endsWith(TEMPLATE_EXTENSION)
+        ? templateRef
+        : `${templateRef}${TEMPLATE_EXTENSION}`;
     // Try absolute path from srcDir
     const absolutePath = join(srcDir, templateName);
     if (await pathExists(absolutePath)) {
         return absolutePath;
     }
-    // Try resolving relative to template directories
-    // This is a simplified version - real implementation might need more sophisticated resolution
-    const possiblePaths = [
-        join(srcDir, '_templates', templateName),
-        join(srcDir, '_partials', templateName),
-        join(srcDir, '_layouts', templateName),
-    ];
-    for (const path of possiblePaths) {
-        if (await pathExists(path)) {
-            return path;
+    // Determine the starting directory for hierarchical search (relative to srcDir)
+    const startDir = currentDir ? relative(srcDir, currentDir) : '';
+    // Build list of directories to search (current dir up to srcDir root only)
+    // This ensures we never search outside the source directory boundary
+    const dirsToSearch = [];
+    // Safety check: ensure currentDir is within srcDir (relative path shouldn't start with '..')
+    if (startDir.startsWith('..')) {
+        // If currentDir is outside srcDir, only search at srcDir root
+        dirsToSearch.push('');
+    }
+    else {
+        const pathSegments = startDir === '' ? [] : startDir.split(/[/\\]/);
+        // Add directories from current up to srcDir root (don't go beyond srcDir)
+        if (pathSegments.length > 0) {
+            for (let i = pathSegments.length; i >= 0; i--) {
+                if (i === 0) {
+                    dirsToSearch.push(''); // srcDir root directory
+                }
+                else {
+                    dirsToSearch.push(pathSegments.slice(0, i).join('/'));
+                }
+            }
+        }
+        else {
+            dirsToSearch.push(''); // srcDir root directory only
+        }
+    }
+    // Search each directory level for the template in underscore directories
+    for (const dir of dirsToSearch) {
+        const searchDir = dir ? join(srcDir, dir) : srcDir;
+        try {
+            // Search for template in underscore directories at this level only
+            const pattern = posix.join(searchDir.replace(/\\/g, '/'), '_*', templateName);
+            const matches = await glob(pattern, { absolute: true });
+            if (matches.length > 0) {
+                return matches[0]; // Return first match
+            }
+        }
+        catch {
+            // Continue if directory doesn't exist or can't be read
+            continue;
         }
     }
     return null;

package/dist/core/isg/hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../src/core/isg/hash.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAWhG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiB9E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAanF"}
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../src/core/isg/hash.ts"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAKhG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiB9E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAKnF"}