@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/config.js

@@ -0,0 +1,828 @@
+var {require}=import.meta;import fs from "node:fs";
+import path from "node:path";
+import { resolve } from "node:path";
+import { loadConfigWithResult } from "bunfig";
+import { a11yDirective, screenReaderDirective } from "./a11y.js";
+import { animationGroupDirective, motionDirective, scrollAnimateDirective, transitionDirective } from "./animation.js";
+import { stxRouterDirective } from "./client/directive.js";
+import { heatmapDirective } from "./heatmap.js";
+import { markdownDirectiveHandler } from "./markdown.js";
+import { imgDirective } from "./media/image/directive.js";
+import { videoDirective } from "./media/video/directive.js";
+import { pwaDirectives } from "./pwa/directives.js";
+import { metaDirective, structuredDataDirective } from "./seo.js";
+import { DEFAULT_STATE_DIR, rebaseOntoStateDir, setStateDir, stateDirName } from "./state-dir.js";
+import { webComponentDirectiveHandler } from "./web-components.js";
+export const defaultConfig = {
+  enabled: !0,
+  ssr: !1,
+  partialsDir: "partials",
+  componentsDir: "components",
+  layoutsDir: "layouts",
+  defaultLayout: "default",
+  debug: !1,
+  cache: !0,
+  stateDir: DEFAULT_STATE_DIR,
+  cachePath: ".stx/cache",
+  cacheVersion: "1.0.0",
+  componentRenderCacheBytes: 33554432,
+  build: {
+    pagesDir: "pages",
+    outputDir: "dist",
+    baseUrl: "/",
+    sitemap: !0,
+    minify: !0,
+    cache: !0,
+    cacheDir: ".stx/ssg-cache",
+    concurrency: 10,
+    generate404: !0,
+    publicDir: "public",
+    trailingSlash: !1,
+    cleanOutput: !0
+  },
+  customDirectives: [
+    {
+      name: "markdown",
+      handler: markdownDirectiveHandler,
+      hasEndTag: !0,
+      description: "Render markdown content to HTML"
+    },
+    {
+      name: "webcomponent",
+      handler: webComponentDirectiveHandler,
+      hasEndTag: !1,
+      description: "Include a web component in the template"
+    },
+    a11yDirective,
+    screenReaderDirective,
+    metaDirective,
+    structuredDataDirective,
+    transitionDirective,
+    animationGroupDirective,
+    motionDirective,
+    scrollAnimateDirective,
+    stxRouterDirective,
+    heatmapDirective,
+    imgDirective,
+    videoDirective,
+    ...pwaDirectives
+  ],
+  middleware: [],
+  i18n: {
+    defaultLocale: "en",
+    locale: "en",
+    translationsDir: "translations",
+    format: "yaml",
+    fallbackToKey: !0,
+    cache: !0
+  },
+  webComponents: {
+    enabled: !1,
+    outputDir: "dist/web-components",
+    components: []
+  },
+  docs: {
+    enabled: !1,
+    outputDir: "docs",
+    format: "markdown",
+    components: !0,
+    templates: !0,
+    directives: !0
+  },
+  streaming: {
+    enabled: !0,
+    bufferSize: 16384,
+    strategy: "auto",
+    timeout: 30000
+  },
+  hydration: {
+    enabled: !1,
+    mode: "islands",
+    clientEntry: "src/client.ts",
+    autoMarkers: !0,
+    preload: "lazy"
+  },
+  router: {
+    enabled: !0,
+    container: "main",
+    linkSelector: "a[href]",
+    viewTransitions: !0,
+    scrollToTop: !0,
+    prefetch: !0,
+    cache: !0,
+    cacheTTL: 300000,
+    skipSelectors: '[data-no-router], [target="_blank"]',
+    viewTransitionCSS: {
+      oldRoot: "fade-out 0.15s ease-in",
+      newRoot: "fade-in 0.2s ease-out",
+      oldContent: "slide-out 0.2s ease-in",
+      newContent: "slide-in 0.25s ease-out"
+    }
+  },
+  a11y: {
+    enabled: !0,
+    addSrOnlyStyles: !0,
+    level: "AA",
+    autoFix: !1,
+    ignoreChecks: []
+  },
+  seo: {
+    enabled: !0,
+    socialPreview: !0,
+    defaultConfig: {
+      title: "stx Project",
+      description: "A website built with stx templating engine"
+    }
+  },
+  animation: {
+    enabled: !0,
+    defaultDuration: 300,
+    defaultEase: "ease",
+    respectMotionPreferences: !0,
+    staggerDelay: 50
+  },
+  markdown: {
+    enabled: !0,
+    syntaxHighlighting: {
+      enabled: !0,
+      serverSide: !0,
+      defaultTheme: "github-dark",
+      highlightUnknownLanguages: !0,
+      additionalThemes: [
+        "light-plus",
+        "one-dark-pro",
+        "dracula",
+        "monokai",
+        "solarized-light",
+        "nord",
+        "github-dark"
+      ]
+    }
+  },
+  loops: {
+    maxWhileIterations: 1000,
+    useAltLoopVariable: !1
+  },
+  story: {
+    enabled: !0,
+    outDir: ".stx/dist/story",
+    storyMatch: ["**/*.story.stx"],
+    storyIgnored: ["**/node_modules/**", "**/dist/**", "**/.stx/**"],
+    port: 6006
+  },
+  pwa: {
+    enabled: !1,
+    manifest: {
+      name: "stx App",
+      shortName: "stx",
+      description: "A Progressive Web App built with stx",
+      startUrl: "/",
+      display: "standalone",
+      orientation: "any",
+      themeColor: "#000000",
+      backgroundColor: "#ffffff",
+      scope: "/"
+    },
+    icons: {
+      src: "public/icon.png",
+      sizes: [72, 96, 128, 144, 152, 192, 384, 512],
+      generateWebP: !0,
+      generateAppleIcons: !0,
+      outputDir: "pwa-icons",
+      purpose: ["any", "maskable"]
+    },
+    routes: [
+      { pattern: "/", strategy: "network-first" },
+      { pattern: "/static/*", strategy: "cache-first", maxAgeSeconds: 2592000 },
+      { pattern: "/api/*", strategy: "network-only" },
+      { pattern: "*.js", strategy: "stale-while-revalidate" },
+      { pattern: "*.css", strategy: "stale-while-revalidate" },
+      { pattern: "*.png", strategy: "cache-first" },
+      { pattern: "*.jpg", strategy: "cache-first" },
+      { pattern: "*.webp", strategy: "cache-first" },
+      { pattern: "*.svg", strategy: "cache-first" }
+    ],
+    offline: {
+      enabled: !0,
+      fallbackTitle: "You are offline",
+      fallbackMessage: "Please check your internet connection and try again.",
+      precacheAssets: []
+    },
+    serviceWorker: {
+      fileName: "sw.js",
+      cacheVersion: "1.0.0",
+      skipWaiting: !0,
+      clientsClaim: !0,
+      navigationPreload: !1,
+      excludeRoutes: ["/api/auth/*"],
+      cacheFileTypes: ["html", "css", "js", "png", "jpg", "jpeg", "webp", "svg", "woff", "woff2"],
+      useWorkbox: !1
+    },
+    autoInject: !0,
+    push: {
+      enabled: !1,
+      defaultOptions: {
+        vibrate: [100, 50, 100],
+        requireInteraction: !1
+      }
+    },
+    backgroundSync: {
+      enabled: !1,
+      queueName: "stx-sync-queue",
+      maxRetentionMinutes: 1440,
+      maxRetries: 3,
+      minInterval: 1000,
+      forms: [],
+      endpoints: []
+    },
+    shareTarget: {
+      enabled: !1,
+      action: "/share-target",
+      method: "POST",
+      enctype: "multipart/form-data",
+      params: {
+        title: "title",
+        text: "text",
+        url: "url"
+      }
+    },
+    fileHandlers: {
+      enabled: !1
+    },
+    protocolHandlers: [],
+    cacheStorage: {
+      maxSize: 100,
+      maxEntries: 500,
+      maxAge: 30,
+      purgeStrategy: "lru"
+    },
+    updates: {
+      enabled: !0,
+      promptUser: !0,
+      autoReload: !1,
+      message: "A new version is available. Reload to update?"
+    },
+    precache: {
+      enabled: !0,
+      includeHtml: !0,
+      includeJs: !0,
+      includeCss: !0,
+      includeImages: !0,
+      includeFonts: !0,
+      include: [],
+      exclude: ["*.map", "*.LICENSE.txt"],
+      maxFileSizeKB: 500
+    }
+  },
+  media: {
+    enabled: !0,
+    image: {
+      enabled: !0,
+      defaultWidths: [320, 480, 640, 768, 1024, 1280, 1536, 1920],
+      defaultFormats: ["avif", "webp", "jpeg"],
+      defaultQuality: 80,
+      placeholderStrategy: "thumbhash",
+      lazyByDefault: !0,
+      enableDpr: !0,
+      defaultDpr: [1, 2, 3],
+      tsImages: {
+        enabled: !0,
+        outputDir: "dist/images",
+        baseUrl: "/images",
+        formatQuality: {
+          jpeg: { quality: 85, mozjpeg: !0, progressive: !0 },
+          png: { compressionLevel: 9, palette: !1 },
+          webp: { quality: 82, effort: 5, smartSubsample: !0 },
+          avif: { quality: 75, effort: 4, lossless: !1 }
+        },
+        breakpoints: [320, 480, 640, 768, 1024, 1280, 1536, 1920],
+        batchOptions: {
+          concurrency: 4,
+          optimizationPreset: "web"
+        }
+      }
+    },
+    video: {
+      enabled: !0,
+      lazyByDefault: !0,
+      defaultControls: !0,
+      tsVideos: {
+        enabled: !0,
+        outputDir: "dist/videos",
+        baseUrl: "/videos",
+        defaultQuality: "high",
+        streaming: {
+          enabled: !0,
+          format: "hls",
+          segmentDuration: 6,
+          defaultQualities: [
+            { label: "1080p", width: 1920, height: 1080, bitrate: 5000000, audioBitrate: 192000 },
+            { label: "720p", width: 1280, height: 720, bitrate: 2500000, audioBitrate: 128000 },
+            { label: "480p", width: 854, height: 480, bitrate: 1e6, audioBitrate: 96000 }
+          ]
+        },
+        thumbnails: {
+          enabled: !0,
+          count: 10,
+          format: "webp",
+          width: 320
+        },
+        transcoding: {
+          defaultCodec: "h264",
+          defaultAudioCodec: "aac",
+          speedPreset: "medium"
+        }
+      }
+    },
+    upload: {
+      enabled: !0,
+      maxSize: 10485760,
+      allowedTypes: ["image/*", "video/*", "audio/*", "application/pdf"],
+      maxConcurrent: 3
+    },
+    protected: {
+      enabled: !0,
+      expirationSeconds: 3600,
+      batchSize: 10
+    },
+    cache: {
+      enabled: !0,
+      directory: ".stx/media-cache",
+      maxAge: 30,
+      maxSize: 500
+    }
+  },
+  broadcasting: {
+    enabled: !1,
+    driver: "bun",
+    host: "0.0.0.0",
+    port: 6001,
+    scheme: "ws",
+    verbose: !1
+  }
+};
+function resolveStxRoot(configRoot, configPagesDir, cwd) {
+  const defaultPagesDir = configPagesDir || "pages";
+  if (configRoot)
+    return { root: configRoot, pagesDir: defaultPagesDir };
+  const base = cwd || process.cwd(), resourcesViews = path.join(base, "resources", "views"), resourcesLayouts = path.join(base, "resources", "layouts");
+  if (fs.existsSync(resourcesViews) && fs.existsSync(resourcesLayouts))
+    return { root: "resources", pagesDir: "views" };
+  const resourcesViewsPages = path.join(base, "resources", "views", "pages");
+  if (fs.existsSync(resourcesViewsPages))
+    return { root: "resources/views", pagesDir: defaultPagesDir };
+  return { root: ".", pagesDir: defaultPagesDir };
+}
+const announcedRoots = new Set, DIR_KEYS = ["partialsDir", "componentsDir", "layoutsDir"], rawDirValues = new WeakMap;
+function alreadyUnderRoot(value, root) {
+  const normalizedRoot = root.replace(/[\\/]+$/, "");
+  if (!normalizedRoot || normalizedRoot === ".")
+    return !0;
+  const normalizedValue = value.replace(/\\/g, "/"), rootAsPosix = normalizedRoot.replace(/\\/g, "/");
+  return normalizedValue === rootAsPosix || normalizedValue.startsWith(`${rootAsPosix}/`);
+}
+export function resolveStxDirectories(loaded, cwd) {
+  const inferred = !loaded.root, resolved = resolveStxRoot(loaded.root, loaded.pagesDir, cwd);
+  loaded.root = resolved.root;
+  loaded.pagesDir = resolved.pagesDir;
+  if (inferred && resolved.root !== ".") {
+    const announceKey = `${cwd}::${resolved.root}`;
+    if (!announcedRoots.has(announceKey)) {
+      announcedRoots.add(announceKey);
+      console.warn(`[stx] No "root" in config \u2014 inferred "${resolved.root}" from the project layout. Template directories are resolved under it; set root explicitly to pin this.`);
+    }
+  }
+  if (!rawDirValues.has(loaded)) {
+    const raw = {};
+    for (const key of DIR_KEYS) {
+      const value = loaded[key];
+      if (typeof value === "string" && value)
+        raw[key] = value;
+    }
+    rawDirValues.set(loaded, raw);
+  }
+  if (loaded.root && loaded.root !== ".") {
+    const rootPrefix = loaded.root;
+    for (const key of DIR_KEYS) {
+      const value = loaded[key];
+      if (typeof value !== "string" || !value)
+        continue;
+      if (path.isAbsolute(value) || alreadyUnderRoot(value, rootPrefix))
+        continue;
+      loaded[key] = path.join(rootPrefix, value);
+    }
+  }
+  for (const key of DIR_KEYS) {
+    const value = loaded[key];
+    if (typeof value !== "string" || !value || path.isAbsolute(value))
+      continue;
+    loaded[key] = path.resolve(cwd, value);
+  }
+  return loaded;
+}
+function warnMissingDirs(loaded, cwd) {
+  const raw = rawDirValues.get(loaded);
+  for (const key of DIR_KEYS) {
+    const value = loaded[key];
+    if (typeof value !== "string" || !value)
+      continue;
+    const abs = path.isAbsolute(value) ? value : path.join(cwd, value);
+    if (fs.existsSync(abs))
+      continue;
+    const configured = raw?.[key] ?? value, root = loaded.root, underRoot = !!root && root !== ".";
+    console.warn(`[stx] ${String(key)} resolves to "${abs}", which does not exist. Configured as "${configured}"` + (underRoot ? `, resolved under root "${root}".` : "."));
+  }
+}
+function detachMutableContainers(loaded) {
+  if (loaded.customDirectives)
+    loaded.customDirectives = [...loaded.customDirectives];
+  if (loaded.middleware)
+    loaded.middleware = [...loaded.middleware];
+  if (loaded.apiRoutes)
+    loaded.apiRoutes = { ...loaded.apiRoutes };
+}
+function applyStateDir(loaded) {
+  setStateDir(loaded.stateDir);
+  loaded.stateDir = stateDirName();
+  loaded.cachePath = rebaseOntoStateDir(loaded.cachePath);
+  if (loaded.build)
+    loaded.build.cacheDir = rebaseOntoStateDir(loaded.build.cacheDir);
+  if (loaded.media?.cache)
+    loaded.media.cache.directory = rebaseOntoStateDir(loaded.media.cache.directory);
+  if (loaded.story)
+    loaded.story.outDir = rebaseOntoStateDir(loaded.story.outDir);
+}
+let _config = null;
+const _cwdConfigCache = new Map;
+let _configPromise = null;
+export async function loadStxConfig(cwd) {
+  if (!cwd) {
+    if (_config)
+      return _config;
+    if (_configPromise)
+      return _configPromise;
+  }
+  const effectiveCwd = cwd ? path.resolve(cwd) : process.cwd(), cached = _cwdConfigCache.get(effectiveCwd);
+  if (cached)
+    return cached;
+  const promise = (async () => {
+    const loaded = (await loadConfigWithResult({
+      name: "stx",
+      alias: "ui",
+      cwd: effectiveCwd,
+      defaultConfig,
+      verbose: !1
+    })).config;
+    detachMutableContainers(loaded);
+    applyStateDir(loaded);
+    resolveStxDirectories(loaded, effectiveCwd);
+    warnMissingDirs(loaded, effectiveCwd);
+    if (loaded.plugins && loaded.plugins.length > 0) {
+      const { pluginManager } = await import("./plugin-system.js"), pluginComponentDirs = [], pluginPageDirs = [];
+      for (const pluginEntry of loaded.plugins) {
+        const pluginPath = typeof pluginEntry === "string" ? pluginEntry : pluginEntry[0], pluginOptions = typeof pluginEntry === "string" ? {} : pluginEntry[1] || {};
+        try {
+          let pluginModule, pluginDir;
+          try {
+            pluginModule = await import(pluginPath);
+            pluginDir = path.dirname(require.resolve(pluginPath));
+          } catch {
+            const resolvedPath = path.resolve(process.cwd(), pluginPath);
+            pluginModule = await import(resolvedPath);
+            pluginDir = path.dirname(resolvedPath);
+          }
+          const plugin = pluginModule.default || pluginModule;
+          if (!pluginManager.has(plugin.name))
+            await pluginManager.register(plugin, loaded);
+          if (plugin.components) {
+            const dirs = Array.isArray(plugin.components) ? plugin.components : [plugin.components];
+            for (const entry of dirs)
+              pluginComponentDirs.push(path.resolve(pluginDir, entry));
+          }
+          if (plugin.pages) {
+            const dir = path.resolve(pluginDir, plugin.pages), prefix = pluginOptions.path || "/";
+            pluginPageDirs.push({ dir, prefix });
+          }
+          if (plugin.setup) {
+            const setupCtx = {
+              addDirective: (d) => {
+                loaded.customDirectives = loaded.customDirectives || [];
+                loaded.customDirectives.push(d);
+              },
+              addRoute: (routePath, handler) => {
+                loaded.apiRoutes = loaded.apiRoutes || {};
+                loaded.apiRoutes[routePath] = handler;
+              },
+              addMiddleware: (mw) => {
+                loaded.middleware = loaded.middleware || [];
+                loaded.middleware.push(mw);
+              },
+              pluginDir,
+              config: loaded
+            };
+            await plugin.setup(pluginOptions, setupCtx);
+          }
+          console.log(`[stx] Plugin loaded: ${plugin.name || pluginPath}`);
+        } catch (e) {
+          console.warn(`[stx] Failed to load plugin ${pluginPath}:`, e.message);
+        }
+      }
+      loaded._pluginComponentDirs = pluginComponentDirs;
+      loaded._pluginPageDirs = pluginPageDirs;
+    }
+    return loaded;
+  })();
+  _cwdConfigCache.set(effectiveCwd, promise);
+  if (!cwd) {
+    _configPromise = promise;
+    promise.then((c) => {
+      _config = c;
+    }).catch(() => {});
+  }
+  return promise;
+}
+export const config = new Proxy(defaultConfig, {
+  get(target, prop) {
+    if (_config && prop in _config)
+      return _config[prop];
+    if (!_configPromise)
+      loadStxConfig().catch((err) => {
+        console.warn("[stx] Failed to load config file:", err?.message || err);
+      });
+    return target[prop];
+  }
+});
+export function defineStxConfig(config) {
+  return config;
+}
+export function validateConfig(config) {
+  const errors = [], warnings = [];
+  if (config.partialsDir !== void 0 && typeof config.partialsDir !== "string")
+    errors.push({
+      path: "partialsDir",
+      message: "partialsDir must be a string",
+      severity: "error"
+    });
+  if (config.componentsDir !== void 0 && typeof config.componentsDir !== "string")
+    errors.push({
+      path: "componentsDir",
+      message: "componentsDir must be a string",
+      severity: "error"
+    });
+  if (config.cache !== void 0 && typeof config.cache !== "boolean")
+    errors.push({
+      path: "cache",
+      message: "cache must be a boolean",
+      severity: "error"
+    });
+  if (config.debug !== void 0 && typeof config.debug !== "boolean")
+    errors.push({
+      path: "debug",
+      message: "debug must be a boolean",
+      severity: "error"
+    });
+  if (config.streaming) {
+    if (config.streaming.bufferSize !== void 0) {
+      if (typeof config.streaming.bufferSize !== "number" || config.streaming.bufferSize <= 0)
+        errors.push({
+          path: "streaming.bufferSize",
+          message: "streaming.bufferSize must be a positive number",
+          severity: "error"
+        });
+    }
+    if (config.streaming.timeout !== void 0) {
+      if (typeof config.streaming.timeout !== "number" || config.streaming.timeout <= 0)
+        errors.push({
+          path: "streaming.timeout",
+          message: "streaming.timeout must be a positive number",
+          severity: "error"
+        });
+    }
+    if (config.streaming.strategy !== void 0) {
+      const validStrategies = ["auto", "manual", "sections"];
+      if (!validStrategies.includes(config.streaming.strategy))
+        errors.push({
+          path: "streaming.strategy",
+          message: `streaming.strategy must be one of: ${validStrategies.join(", ")}`,
+          severity: "error"
+        });
+    }
+  }
+  if (config.i18n) {
+    if (config.i18n.format !== void 0) {
+      const validFormats = ["json", "yaml", "yml", "js"];
+      if (!validFormats.includes(config.i18n.format))
+        errors.push({
+          path: "i18n.format",
+          message: `i18n.format must be one of: ${validFormats.join(", ")}`,
+          severity: "error"
+        });
+    }
+  }
+  if (config.animation) {
+    if (config.animation.defaultDuration !== void 0) {
+      if (typeof config.animation.defaultDuration !== "number" || config.animation.defaultDuration < 0)
+        errors.push({
+          path: "animation.defaultDuration",
+          message: "animation.defaultDuration must be a non-negative number",
+          severity: "error"
+        });
+    }
+    if (config.animation.staggerDelay !== void 0) {
+      if (typeof config.animation.staggerDelay !== "number" || config.animation.staggerDelay < 0)
+        errors.push({
+          path: "animation.staggerDelay",
+          message: "animation.staggerDelay must be a non-negative number",
+          severity: "error"
+        });
+    }
+  }
+  if (config.a11y) {
+    if (config.a11y.level !== void 0) {
+      const validLevels = ["AA", "AAA"];
+      if (!validLevels.includes(config.a11y.level))
+        errors.push({
+          path: "a11y.level",
+          message: `a11y.level must be one of: ${validLevels.join(", ")}`,
+          severity: "error"
+        });
+    }
+  }
+  if (config.hydration) {
+    if (config.hydration.mode !== void 0) {
+      const validModes = ["progressive", "islands"];
+      if (!validModes.includes(config.hydration.mode))
+        errors.push({
+          path: "hydration.mode",
+          message: `hydration.mode must be one of: ${validModes.join(", ")}`,
+          severity: "error"
+        });
+    }
+    if (config.hydration.preload !== void 0) {
+      const validPreloads = ["none", "eager", "lazy"];
+      if (!validPreloads.includes(config.hydration.preload))
+        errors.push({
+          path: "hydration.preload",
+          message: `hydration.preload must be one of: ${validPreloads.join(", ")}`,
+          severity: "error"
+        });
+    }
+  }
+  if (config.customDirectives)
+    if (!Array.isArray(config.customDirectives))
+      errors.push({
+        path: "customDirectives",
+        message: "customDirectives must be an array",
+        severity: "error"
+      });
+    else
+      config.customDirectives.forEach((directive, index) => {
+        if (!directive.name || typeof directive.name !== "string")
+          errors.push({
+            path: `customDirectives[${index}].name`,
+            message: "Custom directive must have a name string",
+            severity: "error"
+          });
+        if (!directive.handler || typeof directive.handler !== "function")
+          errors.push({
+            path: `customDirectives[${index}].handler`,
+            message: "Custom directive must have a handler function",
+            severity: "error"
+          });
+      });
+  if (config.middleware)
+    if (!Array.isArray(config.middleware))
+      errors.push({
+        path: "middleware",
+        message: "middleware must be an array",
+        severity: "error"
+      });
+    else
+      config.middleware.forEach((mw, index) => {
+        if (!mw.name || typeof mw.name !== "string")
+          errors.push({
+            path: `middleware[${index}].name`,
+            message: "Middleware must have a name string",
+            severity: "error"
+          });
+        if (!mw.handler || typeof mw.handler !== "function")
+          errors.push({
+            path: `middleware[${index}].handler`,
+            message: "Middleware must have a handler function",
+            severity: "error"
+          });
+        if (!mw.timing || !["before", "after"].includes(mw.timing))
+          errors.push({
+            path: `middleware[${index}].timing`,
+            message: 'Middleware timing must be "before" or "after"',
+            severity: "error"
+          });
+      });
+  if (config.debug === !0 && config.cache === !0)
+    warnings.push({
+      path: "debug+cache",
+      message: "Debug mode with caching enabled may show stale content during development",
+      severity: "warning"
+    });
+  if (config.seo?.enabled === !0 && !config.seo?.defaultConfig?.title)
+    warnings.push({
+      path: "seo.defaultConfig.title",
+      message: "SEO is enabled but no default title is set",
+      severity: "warning"
+    });
+  if (config.pwa) {
+    if (config.pwa.enabled === !0 && !config.pwa.manifest?.name)
+      errors.push({
+        path: "pwa.manifest.name",
+        message: "PWA manifest name is required when PWA is enabled",
+        severity: "error"
+      });
+    if (config.pwa.manifest?.display !== void 0) {
+      const validDisplayModes = ["fullscreen", "standalone", "minimal-ui", "browser"];
+      if (!validDisplayModes.includes(config.pwa.manifest.display))
+        errors.push({
+          path: "pwa.manifest.display",
+          message: `PWA display must be one of: ${validDisplayModes.join(", ")}`,
+          severity: "error"
+        });
+    }
+    if (config.pwa.manifest?.orientation !== void 0) {
+      const validOrientations = ["portrait", "landscape", "any", "portrait-primary", "portrait-secondary", "landscape-primary", "landscape-secondary"];
+      if (!validOrientations.includes(config.pwa.manifest.orientation))
+        errors.push({
+          path: "pwa.manifest.orientation",
+          message: `PWA orientation must be one of: ${validOrientations.join(", ")}`,
+          severity: "error"
+        });
+    }
+    if (config.pwa.routes) {
+      const validStrategies = ["cache-first", "network-first", "stale-while-revalidate", "network-only", "cache-only"];
+      config.pwa.routes.forEach((route, index) => {
+        if (!route.pattern || typeof route.pattern !== "string")
+          errors.push({
+            path: `pwa.routes[${index}].pattern`,
+            message: "PWA route must have a pattern string",
+            severity: "error"
+          });
+        if (!validStrategies.includes(route.strategy))
+          errors.push({
+            path: `pwa.routes[${index}].strategy`,
+            message: `PWA route strategy must be one of: ${validStrategies.join(", ")}`,
+            severity: "error"
+          });
+        if (route.maxAgeSeconds !== void 0 && (typeof route.maxAgeSeconds !== "number" || route.maxAgeSeconds < 0))
+          errors.push({
+            path: `pwa.routes[${index}].maxAgeSeconds`,
+            message: "PWA route maxAgeSeconds must be a non-negative number",
+            severity: "error"
+          });
+        if (route.maxEntries !== void 0 && (typeof route.maxEntries !== "number" || route.maxEntries < 1))
+          errors.push({
+            path: `pwa.routes[${index}].maxEntries`,
+            message: "PWA route maxEntries must be a positive number",
+            severity: "error"
+          });
+      });
+    }
+    if (config.pwa.icons?.sizes) {
+      if (!Array.isArray(config.pwa.icons.sizes))
+        errors.push({
+          path: "pwa.icons.sizes",
+          message: "PWA icon sizes must be an array of numbers",
+          severity: "error"
+        });
+      else if (config.pwa.icons.sizes.filter((s) => typeof s !== "number" || s < 16 || s > 1024).length > 0)
+        errors.push({
+          path: "pwa.icons.sizes",
+          message: "PWA icon sizes must be numbers between 16 and 1024",
+          severity: "error"
+        });
+    }
+    if (config.pwa.icons?.purpose) {
+      const validPurposes = ["any", "maskable", "monochrome"];
+      if (config.pwa.icons.purpose.filter((p) => !validPurposes.includes(p)).length > 0)
+        errors.push({
+          path: "pwa.icons.purpose",
+          message: `PWA icon purpose must be one of: ${validPurposes.join(", ")}`,
+          severity: "error"
+        });
+    }
+    if (config.pwa.enabled === !0 && !config.pwa.icons?.src)
+      warnings.push({
+        path: "pwa.icons.src",
+        message: "PWA is enabled but no icon source specified. Provide a 512x512 PNG for best results.",
+        severity: "warning"
+      });
+    if (config.pwa.enabled === !0 && !config.pwa.manifest?.themeColor)
+      warnings.push({
+        path: "pwa.manifest.themeColor",
+        message: "PWA theme color not set, defaulting to black",
+        severity: "warning"
+      });
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}