@zenithbuild/core 0.6.17 → 0.7.0

package/dist/config.d.ts

@@ -7,6 +7,26 @@ export interface ZenithConfig {
     pagesDir: string;
     experimental: Record<string, never>;
     strictDomLints: boolean;
+    images: ZenithImageConfig;
+}
+export interface ZenithImageRemotePattern {
+    protocol: string;
+    hostname: string;
+    port?: string;
+    pathname?: string;
+    search?: string;
+}
+export interface ZenithImageConfig {
+    formats: string[];
+    quality: number;
+    deviceSizes: number[];
+    imageSizes: number[];
+    remotePatterns: ZenithImageRemotePattern[];
+    allowSvg: boolean;
+    maxRemoteBytes: number;
+    maxPixels: number;
+    minimumCacheTTL: number;
+    dangerouslyAllowLocalNetwork: boolean;
 }
 type ConfigInput = Partial<ZenithConfig> | null | undefined;
 export declare function validateConfig(config: ConfigInput): ZenithConfig;

package/dist/config.js

@@ -1,5 +1,17 @@
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
+const DEFAULT_IMAGE_CONFIG = {
+    formats: ['webp', 'avif'],
+    quality: 75,
+    deviceSizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840],
+    imageSizes: [16, 32, 48, 64, 96, 128, 256, 384],
+    remotePatterns: [],
+    allowSvg: false,
+    maxRemoteBytes: 10 * 1024 * 1024,
+    maxPixels: 40_000_000,
+    minimumCacheTTL: 60,
+    dangerouslyAllowLocalNetwork: false
+};
 const DEFAULTS = {
     router: false,
     embeddedMarkupExpressions: false,
@@ -8,7 +20,8 @@ const DEFAULTS = {
     outDir: 'dist',
     pagesDir: 'pages',
     experimental: {},
-    strictDomLints: false
+    strictDomLints: false,
+    images: DEFAULT_IMAGE_CONFIG
 };
 const SCHEMA = {
     router: 'boolean',
@@ -18,11 +31,140 @@ const SCHEMA = {
     outDir: 'string',
     pagesDir: 'string',
     experimental: 'object',
-    strictDomLints: 'boolean'
+    strictDomLints: 'boolean',
+    images: 'object'
 };
+function cloneImageConfig() {
+    return {
+        formats: [...DEFAULT_IMAGE_CONFIG.formats],
+        quality: DEFAULT_IMAGE_CONFIG.quality,
+        deviceSizes: [...DEFAULT_IMAGE_CONFIG.deviceSizes],
+        imageSizes: [...DEFAULT_IMAGE_CONFIG.imageSizes],
+        remotePatterns: [],
+        allowSvg: DEFAULT_IMAGE_CONFIG.allowSvg,
+        maxRemoteBytes: DEFAULT_IMAGE_CONFIG.maxRemoteBytes,
+        maxPixels: DEFAULT_IMAGE_CONFIG.maxPixels,
+        minimumCacheTTL: DEFAULT_IMAGE_CONFIG.minimumCacheTTL,
+        dangerouslyAllowLocalNetwork: DEFAULT_IMAGE_CONFIG.dangerouslyAllowLocalNetwork
+    };
+}
+function requirePositiveInt(value, key) {
+    if (!Number.isInteger(value) || Number(value) <= 0) {
+        throw new Error(`[Zenith:Config] images.${key} must be a positive integer`);
+    }
+    return Number(value);
+}
+function normalizeStringList(value, key) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error(`[Zenith:Config] images.${key} must be a non-empty array`);
+    }
+    const out = value.map((entry) => {
+        if (typeof entry !== 'string' || entry.trim() === '') {
+            throw new Error(`[Zenith:Config] images.${key} must contain non-empty strings`);
+        }
+        return entry.trim().toLowerCase();
+    });
+    return [...new Set(out)];
+}
+function normalizePositiveIntList(value, key) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error(`[Zenith:Config] images.${key} must be a non-empty array`);
+    }
+    const out = value.map((entry) => requirePositiveInt(entry, key));
+    return [...new Set(out)].sort((left, right) => left - right);
+}
+function normalizeRemotePatterns(value) {
+    if (!Array.isArray(value)) {
+        throw new Error('[Zenith:Config] images.remotePatterns must be an array');
+    }
+    return value.map((entry) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            throw new Error('[Zenith:Config] images.remotePatterns must contain plain objects');
+        }
+        const protocol = typeof entry.protocol === 'string' && entry.protocol.trim().length > 0
+            ? entry.protocol.trim().replace(/:$/, '').toLowerCase()
+            : 'https';
+        const hostname = typeof entry.hostname === 'string' ? entry.hostname.trim().toLowerCase() : '';
+        if (!hostname) {
+            throw new Error('[Zenith:Config] images.remotePatterns[].hostname is required');
+        }
+        return {
+            protocol,
+            hostname,
+            port: typeof entry.port === 'string' ? entry.port.trim() : '',
+            pathname: typeof entry.pathname === 'string' && entry.pathname.trim().length > 0
+                ? entry.pathname.trim()
+                : '/**',
+            search: typeof entry.search === 'string' ? entry.search : ''
+        };
+    });
+}
+function normalizeImageConfig(input) {
+    if (input === undefined || input === null) {
+        return cloneImageConfig();
+    }
+    if (typeof input !== 'object' || Array.isArray(input)) {
+        throw new Error('[Zenith:Config] images must be a plain object');
+    }
+    const allowed = new Set([
+        'formats',
+        'quality',
+        'deviceSizes',
+        'imageSizes',
+        'remotePatterns',
+        'allowSvg',
+        'maxRemoteBytes',
+        'maxPixels',
+        'minimumCacheTTL',
+        'dangerouslyAllowLocalNetwork'
+    ]);
+    for (const key of Object.keys(input)) {
+        if (!allowed.has(key)) {
+            throw new Error(`[Zenith:Config] Unknown key: "images.${key}"`);
+        }
+    }
+    const config = cloneImageConfig();
+    if ('formats' in input) {
+        config.formats = normalizeStringList(input.formats, 'formats');
+    }
+    if ('quality' in input) {
+        config.quality = requirePositiveInt(input.quality, 'quality');
+    }
+    if ('deviceSizes' in input) {
+        config.deviceSizes = normalizePositiveIntList(input.deviceSizes, 'deviceSizes');
+    }
+    if ('imageSizes' in input) {
+        config.imageSizes = normalizePositiveIntList(input.imageSizes, 'imageSizes');
+    }
+    if ('remotePatterns' in input) {
+        config.remotePatterns = normalizeRemotePatterns(input.remotePatterns);
+    }
+    if ('allowSvg' in input) {
+        if (typeof input.allowSvg !== 'boolean') {
+            throw new Error('[Zenith:Config] images.allowSvg must be boolean');
+        }
+        config.allowSvg = Boolean(input.allowSvg);
+    }
+    if ('maxRemoteBytes' in input) {
+        config.maxRemoteBytes = requirePositiveInt(input.maxRemoteBytes, 'maxRemoteBytes');
+    }
+    if ('maxPixels' in input) {
+        config.maxPixels = requirePositiveInt(input.maxPixels, 'maxPixels');
+    }
+    if ('minimumCacheTTL' in input) {
+        config.minimumCacheTTL = requirePositiveInt(input.minimumCacheTTL, 'minimumCacheTTL');
+    }
+    if ('dangerouslyAllowLocalNetwork' in input) {
+        if (typeof input.dangerouslyAllowLocalNetwork !== 'boolean') {
+            throw new Error('[Zenith:Config] images.dangerouslyAllowLocalNetwork must be boolean');
+        }
+        config.dangerouslyAllowLocalNetwork = Boolean(input.dangerouslyAllowLocalNetwork);
+    }
+    return config;
+}
 export function validateConfig(config) {
     if (config === null || config === undefined) {
-        return { ...DEFAULTS };
+        return { ...DEFAULTS, images: cloneImageConfig() };
     }
     if (typeof config !== 'object' || Array.isArray(config)) {
         throw new Error('[Zenith:Config] Config must be a plain object');
@@ -32,7 +174,7 @@ export function validateConfig(config) {
             throw new Error(`[Zenith:Config] Unknown key: "${key}"`);
         }
     }
-    const result = { ...DEFAULTS };
+    const result = { ...DEFAULTS, images: cloneImageConfig() };
     for (const [key, expectedType] of Object.entries(SCHEMA)) {
         if (key in config) {
             const value = config[key];
@@ -49,6 +191,10 @@ export function validateConfig(config) {
                 result[key] = { ...DEFAULTS.experimental };
                 continue;
             }
+            if (key === 'images') {
+                result.images = normalizeImageConfig(value);
+                continue;
+            }
             result[key] = value;
         }
     }
@@ -68,11 +214,11 @@ export async function loadConfig(projectRoot) {
             error.code === 'ENOENT' ||
             error.message?.includes('Cannot find module') ||
             error.message?.includes('ENOENT')) {
-            return { ...DEFAULTS };
+            return { ...DEFAULTS, images: cloneImageConfig() };
         }
         throw err;
     }
 }
 export function getDefaults() {
-    return { ...DEFAULTS };
+    return { ...DEFAULTS, images: cloneImageConfig() };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenithbuild/core",
-  "version": "0.6.17",
+  "version": "0.7.0",
   "description": "Deterministic utility substrate for the Zenith framework",
   "license": "MIT",
   "type": "module",
@@ -43,11 +43,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@zenithbuild/cli": "0.6.17",
-    "@zenithbuild/compiler": "0.6.17",
-    "@zenithbuild/runtime": "0.6.17",
-    "@zenithbuild/router": "0.6.17",
-    "@zenithbuild/bundler": "0.6.17"
+    "@zenithbuild/cli": "0.7.0",
+    "@zenithbuild/compiler": "0.7.0",
+    "@zenithbuild/runtime": "0.7.0",
+    "@zenithbuild/router": "0.7.0",
+    "@zenithbuild/bundler": "0.7.0"
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.build.json",