@eleventy-plugin-themer/build-vite 0.1.0

package/utils/merge-config.mjs

@@ -0,0 +1,99 @@
+/**
+ * Utilities for merging Vite configuration objects
+ *
+ * Provides deep merge functionality for Vite config, handling nested
+ * objects like resolve.alias, css.preprocessorOptions, and plugins arrays.
+ */
+
+import { UNSAFE_KEYS } from '@eleventy-plugin-themer/core/internal/safe-keys';
+
+/**
+ * Deep merge Vite configuration objects.
+ *
+ * Merges a base theme config with user-provided overrides.
+ * Handles special cases for Vite's nested config structure:
+ * - resolve.alias: Merged (user aliases override theme)
+ * - css.preprocessorOptions.scss: Merged deeply
+ * - plugins: Concatenated (theme first, then user)
+ *
+ * NOTE: Distinct from `deepMergeConfig` in core by design. This variant is
+ * shallow with an explicit set of deep-merge keys (`resolve`, `css`,
+ * `build` incl. `rollupOptions.input`, `server`) matched to Vite's config
+ * shape. Other top-level keys use shallow spread. If you add a new
+ * deep-merge key, update both this function and its tests.
+ *
+ * @param {Object} themeConfig - Base theme Vite configuration
+ * @param {Object} userConfig - User's Vite configuration overrides
+ * @returns {Object} Merged Vite configuration
+ *
+ * @example
+ * const mergedConfig = deepMergeViteConfig(themeConfig, {
+ *   resolve: { alias: { '@custom': '/path/to/custom' } },
+ *   css: { preprocessorOptions: { scss: { additionalData: '$color: red;' } } },
+ * });
+ */
+export function deepMergeViteConfig(themeConfig, userConfig = {}) {
+  // Strip unsafe keys to prevent prototype pollution
+  const safeTheme = Object.fromEntries(
+    Object.entries(themeConfig).filter(([k]) => !UNSAFE_KEYS.has(k)),
+  );
+  const safeUser = Object.fromEntries(
+    Object.entries(userConfig).filter(([k]) => !UNSAFE_KEYS.has(k)),
+  );
+
+  // Extract plugins for special handling (concatenation, not merge)
+  const themePlugins = safeTheme.plugins || [];
+  const userPlugins = safeUser.plugins || [];
+
+  return {
+    ...safeTheme,
+    ...safeUser,
+
+    // Deep merge resolve options
+    resolve: {
+      ...safeTheme.resolve,
+      ...(safeUser.resolve || {}),
+      alias: {
+        ...(safeTheme.resolve?.alias || {}),
+        ...(safeUser.resolve?.alias || {}),
+      },
+    },
+
+    // Deep merge CSS options
+    css: {
+      ...safeTheme.css,
+      ...(safeUser.css || {}),
+      preprocessorOptions: {
+        ...(safeTheme.css?.preprocessorOptions || {}),
+        ...(safeUser.css?.preprocessorOptions || {}),
+        scss: {
+          ...(safeTheme.css?.preprocessorOptions?.scss || {}),
+          ...(safeUser.css?.preprocessorOptions?.scss || {}),
+        },
+      },
+    },
+
+    // Deep merge build options
+    build: {
+      ...(safeTheme.build || {}),
+      ...(safeUser.build || {}),
+      rollupOptions: {
+        ...(safeTheme.build?.rollupOptions || {}),
+        ...(safeUser.build?.rollupOptions || {}),
+        input: {
+          ...(safeTheme.build?.rollupOptions?.input || {}),
+          ...(safeUser.build?.rollupOptions?.input || {}),
+        },
+      },
+    },
+
+    // Deep merge server options
+    server: {
+      ...(safeTheme.server || {}),
+      ...(safeUser.server || {}),
+    },
+
+    // Concatenate plugins (theme first, then user)
+    plugins: [...themePlugins, ...userPlugins],
+  };
+}

package/utils/plugin-orchestrator.mjs

@@ -0,0 +1,74 @@
+/**
+ * Plugin orchestration utility
+ * Maps config keys to plugin functions via explicit registry
+ */
+
+import { logger } from '@eleventy-plugin-themer/core/logger';
+
+import {
+  purgeCSSFiles,
+  generateCriticalCSS,
+  minifyHTML,
+  validateLinks,
+  preserveNonHtmlFiles,
+} from '../plugins/index.mjs';
+
+/**
+ * Explicit mapping from optimization config keys to plugin functions.
+ * Add new plugins here when they are created.
+ */
+const PLUGIN_REGISTRY = {
+  purgeCSS: purgeCSSFiles,
+  criticalCSS: generateCriticalCSS,
+  minifyHTML: minifyHTML,
+  validateLinks: validateLinks,
+  preserveNonHtml: preserveNonHtmlFiles,
+};
+
+/**
+ * Set of valid optimization keys, exposed so consumers (and `eleventyPluginThemerVite`)
+ * can fail-fast on typos in user-supplied `optimizations` rather than silently no-op.
+ */
+export const KNOWN_OPTIMIZATIONS = new Set(Object.keys(PLUGIN_REGISTRY));
+
+/**
+ * Run optimization plugins based on configuration
+ *
+ * All plugins follow a uniform signature: (outputDir, options) => Promise<void>
+ * The dirs object is merged into options so plugins can access temp, output, etc.
+ *
+ * @param {Object} optimizations - Optimization configuration (key: true|false|function|object)
+ * @param {Object} dirs - Directory configuration
+ * @param {string} dirs.output - Output directory (required)
+ * @param {string} [dirs.temp] - Temp directory (optional, passed to plugins via options)
+ */
+export async function runOptimizations(optimizations, dirs) {
+  for (const [name, config] of Object.entries(optimizations)) {
+    // Skip if optimization is disabled
+    if (!config) continue;
+
+    // Custom function provided
+    if (typeof config === 'function') {
+      await config();
+      continue;
+    }
+
+    // Built-in plugin
+    if (config === true || typeof config === 'object') {
+      const pluginFn = PLUGIN_REGISTRY[name];
+
+      if (!pluginFn) {
+        logger.warn(
+          `⚠️  No plugin found for optimization: "${name}". Available: ${Object.keys(PLUGIN_REGISTRY).join(', ')}`,
+        );
+        continue;
+      }
+
+      // Merge dirs into options so plugins have access to all paths
+      const userOptions = typeof config === 'object' ? config : {};
+      const options = { ...dirs, ...userOptions };
+
+      await pluginFn(dirs.output, options);
+    }
+  }
+}