@stati/core 1.0.0 → 1.2.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/core/dev.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAe,MAAM,EAAE,MAAM,aAAa,CAAC;AAMvD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,SAAS,CAAC,CA0ZxF"}

package/dist/core/dev.js

@@ -0,0 +1,371 @@
+import { createServer } from 'http';
+import { join, extname } from 'path';
+import { posix } from 'path';
+import { readFile, stat } from 'fs/promises';
+import { WebSocketServer } from 'ws';
+import chokidar from 'chokidar';
+import { build } from './build.js';
+import { loadConfig } from '../config/loader.js';
+import { loadCacheManifest, saveCacheManifest } from './isg/manifest.js';
+/**
+ * Creates and configures a development server with live reload functionality.
+ *
+ * @param options - Development server configuration options
+ * @returns Promise resolving to a DevServer instance
+ */
+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;
+    // Load configuration
+    try {
+        if (configPath) {
+            // For custom config path, we need to change to that directory temporarily
+            // This is a limitation of the current loadConfig implementation
+            logger.info?.(`Loading config from: ${configPath}`);
+        }
+        config = await loadConfig(process.cwd());
+    }
+    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 {
+            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 incrementalRebuild(changedPath) {
+        if (isBuilding) {
+            logger.info?.('⏳ Build in progress, skipping...');
+            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' }));
+                    }
+                });
+            }
+            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
+            await build({
+                logger,
+                force: false,
+                clean: false,
+                ...(configPath && { configPath }),
+            });
+        }
+    }
+    /**
+     * Gets MIME type for a file based on its extension
+     */
+    function getMimeType(filePath) {
+        const ext = extname(filePath).toLowerCase();
+        const mimeTypes = {
+            '.html': 'text/html',
+            '.js': 'application/javascript',
+            '.css': 'text/css',
+            '.json': 'application/json',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.svg': 'image/svg+xml',
+            '.ico': 'image/x-icon',
+            '.webp': 'image/webp',
+            '.woff': 'font/woff',
+            '.woff2': 'font/woff2',
+            '.ttf': 'font/ttf',
+            '.eot': 'application/vnd.ms-fontobject',
+        };
+        return mimeTypes[ext] || 'application/octet-stream';
+    }
+    /**
+     * Injects live reload script into HTML responses
+     */
+    function injectLiveReloadScript(html) {
+        const script = `
+<script>
+(function() {
+  const ws = new WebSocket('ws://${host}:${port}/__ws');
+  ws.onmessage = function(event) {
+    const data = JSON.parse(event.data);
+    if (data.type === 'reload') {
+      console.log('Reloading page due to file changes...');
+      window.location.reload();
+    }
+  };
+  ws.onopen = function() {
+    console.log('Connected to Stati dev server');
+  };
+  ws.onclose = function() {
+    console.log('Lost connection to Stati dev server');
+    // Try to reconnect after a delay
+    setTimeout(() => window.location.reload(), 1000);
+  };
+})();
+</script>`;
+        // Insert before closing </body> tag, or at the end if no </body>
+        if (html.includes('</body>')) {
+            return html.replace('</body>', `${script}\n</body>`);
+        }
+        else {
+            return html + script;
+        }
+    }
+    /**
+     * Serves files from the dist directory
+     */
+    async function serveFile(requestPath) {
+        let filePath = join(outDir, requestPath === '/' ? 'index.html' : requestPath);
+        try {
+            const stats = await stat(filePath);
+            if (stats.isDirectory()) {
+                // Try to serve index.html from directory
+                const indexPath = join(filePath, 'index.html');
+                try {
+                    await stat(indexPath);
+                    filePath = indexPath;
+                }
+                catch {
+                    return {
+                        content: '404 - Directory listing not available',
+                        mimeType: 'text/plain',
+                        statusCode: 404,
+                    };
+                }
+            }
+            const mimeType = getMimeType(filePath);
+            const content = await readFile(filePath);
+            // Inject live reload script into HTML files
+            if (mimeType === 'text/html') {
+                const html = content.toString('utf-8');
+                const injectedHtml = injectLiveReloadScript(html);
+                return {
+                    content: injectedHtml,
+                    mimeType,
+                    statusCode: 200,
+                };
+            }
+            return {
+                content,
+                mimeType,
+                statusCode: 200,
+            };
+        }
+        catch {
+            // File not found
+            return {
+                content: '404 - File not found',
+                mimeType: 'text/plain',
+                statusCode: 404,
+            };
+        }
+    }
+    const devServer = {
+        url,
+        async start() {
+            // Perform initial build
+            await initialBuild();
+            // Create HTTP server
+            httpServer = createServer(async (req, res) => {
+                const requestPath = req.url || '/';
+                // Handle WebSocket upgrade path
+                if (requestPath === '/__ws') {
+                    return; // Let WebSocket server handle this
+                }
+                logger.processing?.(`${req.method} ${requestPath}`);
+                try {
+                    const { content, mimeType, statusCode } = await serveFile(requestPath);
+                    res.writeHead(statusCode, {
+                        'Content-Type': mimeType,
+                        'Access-Control-Allow-Origin': '*',
+                        'Cache-Control': 'no-cache, no-store, must-revalidate',
+                    });
+                    res.end(content);
+                }
+                catch (error) {
+                    logger.error?.(`Server error: ${error instanceof Error ? error.message : String(error)}`);
+                    res.writeHead(500, { 'Content-Type': 'text/plain' });
+                    res.end('500 - Internal Server Error');
+                }
+            });
+            // Create WebSocket server for live reload
+            wsServer = new WebSocketServer({
+                server: httpServer,
+                path: '/__ws',
+            });
+            wsServer.on('connection', (ws) => {
+                logger.info?.('🔗 Browser connected for live reload');
+                const websocket = ws;
+                websocket.on('close', () => {
+                    logger.info?.('Browser disconnected from live reload');
+                });
+            });
+            // Start HTTP server
+            await new Promise((resolve, reject) => {
+                httpServer.listen(port, host, () => {
+                    resolve();
+                });
+                httpServer.on('error', (error) => {
+                    reject(error);
+                });
+            });
+            // Set up file watching
+            const watchPaths = [srcDir, staticDir].filter(Boolean);
+            watcher = chokidar.watch(watchPaths, {
+                ignored: /(^|[/\\])\../, // ignore dotfiles
+                persistent: true,
+                ignoreInitial: true,
+            });
+            watcher.on('change', (path) => {
+                void incrementalRebuild(path);
+            });
+            watcher.on('add', (path) => {
+                void incrementalRebuild(path);
+            });
+            watcher.on('unlink', (path) => {
+                void incrementalRebuild(path);
+            });
+            logger.success?.(`Dev server running at ${url}`);
+            logger.info?.(`\nServing from:`);
+            logger.info?.(`  📁 ${outDir}`);
+            logger.info?.('Watching:');
+            watchPaths.forEach((path) => logger.info?.(`  📁 ${path}`));
+            // Open browser if requested
+            if (open) {
+                try {
+                    const { default: openBrowser } = await import('open');
+                    await openBrowser(url);
+                }
+                catch {
+                    logger.info?.('Could not open browser automatically');
+                }
+            }
+        },
+        async stop() {
+            if (watcher) {
+                await watcher.close();
+                watcher = null;
+            }
+            if (wsServer) {
+                wsServer.close();
+                wsServer = null;
+            }
+            if (httpServer) {
+                await new Promise((resolve) => {
+                    httpServer.close(() => resolve());
+                });
+                httpServer = null;
+            }
+            logger.info?.('🛑 Dev server stopped');
+        },
+    };
+    return devServer;
+}

package/dist/core/invalidate.d.ts

@@ -1,2 +1,68 @@
-export declare function invalidate(query?: string): Promise<void>;
+import type { CacheEntry } from '../types.js';
+/**
+ * Invalidation result containing affected cache entries.
+ */
+export interface InvalidationResult {
+    /** Number of cache entries invalidated */
+    invalidatedCount: number;
+    /** Paths of invalidated pages */
+    invalidatedPaths: string[];
+    /** Whether the entire cache was cleared */
+    clearedAll: boolean;
+}
+/**
+ * Parses an invalidation query string into individual query terms.
+ * Supports space-separated values and quoted strings.
+ *
+ * @param query - The query string to parse
+ * @returns Array of parsed query terms
+ *
+ * @example
+ * ```typescript
+ * parseInvalidationQuery('tag:blog path:/posts') // ['tag:blog', 'path:/posts']
+ * parseInvalidationQuery('"tag:my tag" path:"/my path"') // ['tag:my tag', 'path:/my path']
+ * ```
+ */
+export declare function parseInvalidationQuery(query: string): string[];
+/**
+ * Checks if a cache entry matches a specific invalidation term.
+ *
+ * @param entry - Cache entry to check
+ * @param path - The page path for this entry
+ * @param term - Invalidation term to match against
+ * @returns True if the entry matches the term
+ *
+ * @example
+ * ```typescript
+ * matchesInvalidationTerm(entry, '/blog/post-1', 'tag:blog') // true if entry has 'blog' tag
+ * matchesInvalidationTerm(entry, '/blog/post-1', 'path:/blog') // true (path prefix match)
+ * ```
+ */
+export declare function matchesInvalidationTerm(entry: CacheEntry, path: string, term: string): boolean;
+/**
+ * Invalidates cache entries based on a query string.
+ * Supports tag-based, path-based, pattern-based, and time-based invalidation.
+ *
+ * @param query - Invalidation query string, or undefined to clear all cache
+ * @returns Promise resolving to invalidation result
+ *
+ * @example
+ * ```typescript
+ * // Invalidate all pages with 'blog' tag
+ * await invalidate('tag:blog');
+ *
+ * // Invalidate specific path
+ * await invalidate('path:/about');
+ *
+ * // Invalidate content younger than 3 months
+ * await invalidate('age:3months');
+ *
+ * // Invalidate multiple criteria
+ * await invalidate('tag:blog age:1week');
+ *
+ * // Clear entire cache
+ * await invalidate();
+ * ```
+ */
+export declare function invalidate(query?: string): Promise<InvalidationResult>;
 //# sourceMappingURL=invalidate.d.ts.map

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

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