@stati/core 1.4.0 → 1.6.0

package/dist/core/utils/partial-validation.js

@@ -0,0 +1,129 @@
+/**
+ * Creates inline error overlay HTML for missing partials
+ */
+function createInlineErrorOverlay(partialName, suggestions) {
+    const suggestionText = suggestions.length > 0
+        ? `Did you mean: ${suggestions.map((s) => `"${s}"`).join(', ')}?`
+        : 'No similar partials found';
+    return `
+<!-- Stati Development Error Overlay -->
+<div style="
+  position: fixed;
+  top: 20px;
+  right: 20px;
+  z-index: 999999;
+  background: #dc2626;
+  color: white;
+  padding: 16px;
+  border-radius: 8px;
+  box-shadow: 0 4px 12px rgba(0,0,0,0.3);
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  font-size: 14px;
+  line-height: 1.4;
+  max-width: 400px;
+  border: 2px solid #fca5a5;
+">
+  <div style="font-weight: 600; margin-bottom: 8px; font-size: 16px;">
+    ⚠️ Template Error
+  </div>
+  <div style="margin-bottom: 8px;">
+    <strong>Partial "${partialName}" not found</strong>
+  </div>
+  <div style="color: #fca5a5; font-size: 13px;">
+    ${suggestionText}
+  </div>
+  <div style="margin-top: 12px; padding-top: 8px; border-top: 1px solid #fca5a5; font-size: 12px; opacity: 0.8;">
+    Fix the partial name in your template to dismiss this error
+  </div>
+</div>
+<!-- End Stati Error Overlay -->`;
+}
+/**
+ * Finds similar partial names to suggest when a partial is not found
+ */
+function findSimilarPartialNames(targetName, availableNames) {
+    if (availableNames.length === 0)
+        return [];
+    // Simple similarity check based on common prefixes and substrings
+    const target = targetName.toLowerCase();
+    const suggestions = availableNames
+        .map((name) => {
+        const candidate = name.toLowerCase();
+        let score = 0;
+        // Exact match gets highest score
+        if (candidate === target)
+            return { name, score: 1000 };
+        // Check if one is contained in the other
+        if (candidate.includes(target) || target.includes(candidate)) {
+            score += 100;
+        }
+        // Check common prefix length
+        let prefixLen = 0;
+        for (let i = 0; i < Math.min(target.length, candidate.length); i++) {
+            if (target[i] === candidate[i]) {
+                prefixLen++;
+            }
+            else {
+                break;
+            }
+        }
+        score += prefixLen * 10;
+        // Check common characters
+        const targetChars = new Set(target);
+        const candidateChars = new Set(candidate);
+        const commonChars = [...targetChars].filter((char) => candidateChars.has(char));
+        score += commonChars.length;
+        return { name, score };
+    })
+        .filter((item) => item.score > 0) // Only include items with some similarity
+        .sort((a, b) => b.score - a.score) // Sort by score descending
+        .slice(0, 3) // Top 3 suggestions
+        .map((item) => item.name);
+    return suggestions;
+}
+/**
+ * Creates a development-mode Proxy for the partials object that throws errors
+ * when accessing non-existent partials instead of returning undefined
+ */
+export function createValidatingPartialsProxy(partials) {
+    // In production, return partials as-is
+    // Only skip validation if explicitly set to production
+    if (process.env.NODE_ENV === 'production') {
+        return partials;
+    }
+    return new Proxy(partials, {
+        get(target, prop, receiver) {
+            // Allow normal object operations
+            if (typeof prop === 'symbol') {
+                return Reflect.get(target, prop, receiver);
+            }
+            const propName = String(prop);
+            // Check if the property exists
+            if (propName in target) {
+                return target[propName];
+            }
+            // Special case: allow accessing length, toString, etc.
+            if (propName in Object.prototype || propName === 'length') {
+                return Reflect.get(target, prop, receiver);
+            }
+            // Property doesn't exist - return error overlay HTML instead of throwing
+            const availablePartials = Object.keys(target);
+            const suggestions = findSimilarPartialNames(propName, availablePartials);
+            // Special case: throw error if no partials are available at all
+            if (availablePartials.length === 0) {
+                throw new Error('No partials are available');
+            }
+            // In development, render an inline error overlay
+            return createInlineErrorOverlay(propName, suggestions);
+        },
+        has(target, prop) {
+            return prop in target;
+        },
+        ownKeys(target) {
+            return Reflect.ownKeys(target);
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            return Reflect.getOwnPropertyDescriptor(target, prop);
+        },
+    });
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Result of attempting to resolve a pretty URL path
+ */
+export interface PrettyUrlResult {
+    /** The resolved file path to serve */
+    filePath: string | null;
+    /** Whether the path was found */
+    found: boolean;
+}
+/**
+ * Attempts to resolve pretty URL paths by trying various fallback strategies.
+ * This handles common patterns like:
+ * - /path/ -> /path/index.html
+ * - /path/ -> /path.html (if no index.html exists)
+ * - /path -> /path.html (when original path is not found)
+ *
+ * @param outDir The output directory to serve files from
+ * @param requestPath The requested URL path
+ * @param originalFilePath The original file path that was attempted
+ * @returns Promise resolving to the file path to serve or null if not found
+ */
+export declare function resolvePrettyUrl(outDir: string, requestPath: string, originalFilePath: string): Promise<PrettyUrlResult>;
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/core/utils/server.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,sCAAsC;IACtC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,iCAAiC;IACjC,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,eAAe,CAAC,CA+C1B"}

package/dist/core/utils/server.js

@@ -0,0 +1,61 @@
+import { join } from 'path';
+import { stat } from 'fs/promises';
+/**
+ * Attempts to resolve pretty URL paths by trying various fallback strategies.
+ * This handles common patterns like:
+ * - /path/ -> /path/index.html
+ * - /path/ -> /path.html (if no index.html exists)
+ * - /path -> /path.html (when original path is not found)
+ *
+ * @param outDir The output directory to serve files from
+ * @param requestPath The requested URL path
+ * @param originalFilePath The original file path that was attempted
+ * @returns Promise resolving to the file path to serve or null if not found
+ */
+export async function resolvePrettyUrl(outDir, requestPath, originalFilePath) {
+    try {
+        const stats = await stat(originalFilePath);
+        if (stats.isDirectory()) {
+            // Try to serve index.html from directory
+            const indexPath = join(originalFilePath, 'index.html');
+            try {
+                await stat(indexPath);
+                return { filePath: indexPath, found: true };
+            }
+            catch {
+                // If no index.html in directory, try to serve corresponding .html file
+                // For example: /examples/ -> examples.html
+                const directoryName = requestPath.replace(/\/$/, ''); // Remove trailing slash
+                const fallbackPath = join(outDir, `${directoryName}.html`);
+                try {
+                    await stat(fallbackPath);
+                    return { filePath: fallbackPath, found: true };
+                }
+                catch {
+                    return { filePath: null, found: false };
+                }
+            }
+        }
+        // File exists and is not a directory
+        return { filePath: originalFilePath, found: true };
+    }
+    catch {
+        // File not found, try fallback strategies for pretty URLs
+        if (requestPath.endsWith('/')) {
+            // For requests ending with /, try the corresponding .html file
+            const pathWithoutSlash = requestPath.slice(0, -1);
+            const htmlPath = join(outDir, `${pathWithoutSlash}.html`);
+            try {
+                const stats = await stat(htmlPath);
+                if (stats.isFile()) {
+                    return { filePath: htmlPath, found: true };
+                }
+            }
+            catch {
+                // Continue to not found
+            }
+        }
+        // No fallback worked
+        return { filePath: null, found: false };
+    }
+}

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

@@ -0,0 +1,28 @@
+import type { ErrorDetails } from './error-overlay.js';
+/**
+ * Enhanced template error that includes file context and suggestions.
+ */
+export declare class TemplateError extends Error {
+    readonly filePath?: string;
+    readonly line?: number;
+    readonly column?: number;
+    readonly template?: string;
+    readonly context?: {
+        before?: string[];
+        after?: string[];
+    };
+    constructor(message: string, filePath?: string, line?: number, column?: number, template?: string);
+    /**
+     * Converts this template error to ErrorDetails for the overlay.
+     */
+    toErrorDetails(): Promise<ErrorDetails>;
+}
+/**
+ * Parses Eta template errors to extract file location information.
+ */
+export declare function parseEtaError(error: Error, templatePath?: string): TemplateError;
+/**
+ * Enhances a generic error with template-specific context.
+ */
+export declare function createTemplateError(error: Error, templatePath?: string, _line?: number, _column?: number): TemplateError;
+//# sourceMappingURL=template-errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"template-errors.d.ts","sourceRoot":"","sources":["../../../src/core/utils/template-errors.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;GAEG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,SAAgB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClC,SAAgB,IAAI,CAAC,EAAE,MAAM,CAAC;IAC9B,SAAgB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChC,SAAgB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClC,SAAgB,OAAO,CAAC,EAAE;QACxB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;KAClB,CAAC;gBAGA,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,EACjB,IAAI,CAAC,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM;IAUnB;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,YAAY,CAAC;CAoE9C;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,aAAa,CA8BhF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,KAAK,EACZ,YAAY,CAAC,EAAE,MAAM,EACrB,KAAK,CAAC,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,GACf,aAAa,CAMf"}

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

@@ -0,0 +1,128 @@
+import { readFile } from 'fs/promises';
+import { pathExists } from './fs.js';
+/**
+ * Enhanced template error that includes file context and suggestions.
+ */
+export class TemplateError extends Error {
+    filePath;
+    line;
+    column;
+    template;
+    context;
+    constructor(message, filePath, line, column, template) {
+        super(message);
+        this.name = 'TemplateError';
+        if (filePath !== undefined)
+            this.filePath = filePath;
+        if (line !== undefined)
+            this.line = line;
+        if (column !== undefined)
+            this.column = column;
+        if (template !== undefined)
+            this.template = template;
+    }
+    /**
+     * Converts this template error to ErrorDetails for the overlay.
+     */
+    async toErrorDetails() {
+        const suggestions = [];
+        const message = this.message.toLowerCase();
+        // Add specific suggestions based on error type
+        if (message.includes('not found') || message.includes('cannot resolve')) {
+            suggestions.push('Check if the template file exists and has the correct path');
+            suggestions.push('Verify the template reference in your layout or include statement');
+            suggestions.push('Ensure the template file has the .eta extension');
+        }
+        else if (message.includes('syntax') || message.includes('unexpected')) {
+            suggestions.push('Check for unmatched brackets, quotes, or parentheses');
+            suggestions.push('Verify Eta template syntax is correct');
+            suggestions.push('Look for unclosed template tags');
+        }
+        else if (message.includes('undefined') || message.includes('null')) {
+            suggestions.push('Check if all required data is available in template context');
+            suggestions.push('Add conditional checks for optional template variables');
+            suggestions.push('Verify page frontMatter and data structure');
+        }
+        // Try to read file context if available
+        let context;
+        let code;
+        if (this.filePath && this.line && (await pathExists(this.filePath))) {
+            try {
+                const fileContent = await readFile(this.filePath, 'utf-8');
+                const lines = fileContent.split('\n');
+                const errorLineIndex = this.line - 1;
+                if (errorLineIndex >= 0 && errorLineIndex < lines.length) {
+                    code = lines[errorLineIndex];
+                    // Get surrounding context
+                    const contextLines = 3;
+                    const beforeLines = lines.slice(Math.max(0, errorLineIndex - contextLines), errorLineIndex);
+                    const afterLines = lines.slice(errorLineIndex + 1, Math.min(lines.length, errorLineIndex + contextLines + 1));
+                    context = {
+                        before: beforeLines,
+                        after: afterLines,
+                    };
+                }
+            }
+            catch {
+                // Ignore file read errors
+            }
+        }
+        const errorDetails = {
+            type: 'template',
+            message: this.message,
+            suggestions,
+        };
+        if (this.stack !== undefined)
+            errorDetails.stack = this.stack;
+        if (this.filePath !== undefined)
+            errorDetails.file = this.filePath;
+        if (this.line !== undefined)
+            errorDetails.line = this.line;
+        if (this.column !== undefined)
+            errorDetails.column = this.column;
+        if (code !== undefined)
+            errorDetails.code = code;
+        if (context !== undefined)
+            errorDetails.context = context;
+        return errorDetails;
+    }
+}
+/**
+ * Parses Eta template errors to extract file location information.
+ */
+export function parseEtaError(error, templatePath) {
+    let filePath = templatePath;
+    let line;
+    let column;
+    // Try to parse error location from Eta error messages
+    const message = error.message;
+    // Eta syntax errors often include line/column info
+    const locationMatch = message.match(/at line (\d+), column (\d+)/i);
+    if (locationMatch && locationMatch[1] && locationMatch[2]) {
+        line = parseInt(locationMatch[1], 10);
+        column = parseInt(locationMatch[2], 10);
+    }
+    // Try to extract file path from stack trace if not provided
+    if (!filePath && error.stack) {
+        const stackLines = error.stack.split('\n');
+        for (const stackLine of stackLines) {
+            const fileMatch = stackLine.match(/at.*\(([^)]+\.eta):(\d+):(\d+)\)/);
+            if (fileMatch && fileMatch[1] && fileMatch[2] && fileMatch[3]) {
+                filePath = fileMatch[1];
+                line = parseInt(fileMatch[2], 10);
+                column = parseInt(fileMatch[3], 10);
+                break;
+            }
+        }
+    }
+    return new TemplateError(message, filePath, line, column);
+}
+/**
+ * Enhances a generic error with template-specific context.
+ */
+export function createTemplateError(error, templatePath, _line, _column) {
+    if (error instanceof TemplateError) {
+        return error;
+    }
+    return parseEtaError(error, templatePath);
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Utility functions for Eta templates
+ */
+type PropValueArg = string | number | boolean | null | undefined | Record<string, boolean | string | number | null | undefined> | PropValueArg[];
+/**
+ * Builds a property value from various inputs, similar to classnames but for any property.
+ * Accepts strings, arrays, and objects. Filters out falsy values.
+ *
+ * @param args - Values to combine
+ * @returns Combined property value string
+ *
+ * @example
+ * propValue('class1', 'class2') // 'class1 class2'
+ * propValue(['class1', 'class2']) // 'class1 class2'
+ * propValue({ 'class1': true, 'class2': false }) // 'class1'
+ * propValue('class1', ['class2', 'class3'], { 'class4': true }) // 'class1 class2 class3 class4'
+ */
+export declare function propValue(...args: PropValueArg[]): string;
+export {};
+//# sourceMappingURL=template-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"template-utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/template-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,KAAK,YAAY,GACb,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,GACT,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAC5D,YAAY,EAAE,CAAC;AAEnB;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,GAAG,IAAI,EAAE,YAAY,EAAE,GAAG,MAAM,CAwBzD"}

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

@@ -0,0 +1,39 @@
+/**
+ * Utility functions for Eta templates
+ */
+/**
+ * Builds a property value from various inputs, similar to classnames but for any property.
+ * Accepts strings, arrays, and objects. Filters out falsy values.
+ *
+ * @param args - Values to combine
+ * @returns Combined property value string
+ *
+ * @example
+ * propValue('class1', 'class2') // 'class1 class2'
+ * propValue(['class1', 'class2']) // 'class1 class2'
+ * propValue({ 'class1': true, 'class2': false }) // 'class1'
+ * propValue('class1', ['class2', 'class3'], { 'class4': true }) // 'class1 class2 class3 class4'
+ */
+export function propValue(...args) {
+    const classes = [];
+    for (const arg of args) {
+        if (!arg)
+            continue;
+        if (typeof arg === 'string' || typeof arg === 'number') {
+            classes.push(String(arg));
+        }
+        else if (Array.isArray(arg)) {
+            classes.push(...arg
+                .filter((item) => item && (typeof item === 'string' || typeof item === 'number'))
+                .map(String));
+        }
+        else if (typeof arg === 'object') {
+            for (const [key, value] of Object.entries(arg)) {
+                if (value) {
+                    classes.push(key);
+                }
+            }
+        }
+    }
+    return classes.join(' ');
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Gets the current version of Stati core from package.json
+ * @returns The version string
+ */
+export declare function getStatiVersion(): string;
+//# sourceMappingURL=version.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/core/utils/version.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAWxC"}

package/dist/core/utils/version.js

@@ -0,0 +1,20 @@
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+/**
+ * Gets the current version of Stati core from package.json
+ * @returns The version string
+ */
+export function getStatiVersion() {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const packageJsonPath = join(__dirname, '../../package.json');
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        return packageJson.version;
+    }
+    catch {
+        // Fallback for cases where package.json can't be read
+        return '1.0.0';
+    }
+}

package/dist/env.d.ts

@@ -0,0 +1,3 @@
+export declare function setEnv(env: 'development' | 'production' | 'test'): void;
+export declare function getEnv(): string;
+//# sourceMappingURL=env.d.ts.map

package/dist/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":"AAEA,wBAAgB,MAAM,CAAC,GAAG,EAAE,aAAa,GAAG,YAAY,GAAG,MAAM,QAEhE;AAED,wBAAgB,MAAM,WAErB"}

package/dist/env.js

@@ -0,0 +1,7 @@
+let currentEnv = process.env.NODE_ENV || 'development';
+export function setEnv(env) {
+    currentEnv = env;
+}
+export function getEnv() {
+    return currentEnv;
+}

package/dist/index.d.ts

@@ -29,6 +29,7 @@ export { createDevServer } from './core/dev.js';
 export { createPreviewServer } from './core/preview.js';
 export { loadConfig } from './config/loader.js';
 export { invalidate } from './core/invalidate.js';
+export { setEnv, getEnv } from './env.js';
 import type { StatiConfig } from './types/index.js';
 /**
  * Helper function for defining Stati configuration with TypeScript IntelliSense.

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

package/dist/index.js

@@ -24,6 +24,7 @@ export { createDevServer } from './core/dev.js';
 export { createPreviewServer } from './core/preview.js';
 export { loadConfig } from './config/loader.js';
 export { invalidate } from './core/invalidate.js';
+export { setEnv, getEnv } from './env.js';
 /**
  * Helper function for defining Stati configuration with TypeScript IntelliSense.
  * Provides type checking and autocompletion for configuration options.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stati/core",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",