zylaris 1.0.2

package/packages/plugins/src/loaders/external.ts

@@ -0,0 +1,332 @@
+/**
+ * External Dependencies Optimizer
+ * Smart handling of npm dependencies with pre-bundling
+ */
+
+import { build } from 'esbuild';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import type { ExternalConfig, BundleAnalysis } from '../types.js';
+import { generateCDNUrl } from '../cdn/loader.js';
+
+/** Dependency metadata */
+interface DepMetadata {
+  name: string;
+  version: string;
+  entry: string;
+  browserEntry?: string;
+  sideEffects: boolean | string[];
+  peerDependencies?: string[];
+  size: number;
+}
+
+/** Pre-bundle dependencies */
+export async function prebundleDependencies(
+  deps: string[],
+  options: {
+    outDir?: string;
+    format?: 'esm' | 'cjs' | 'iife';
+    minify?: boolean;
+    sourcemap?: boolean;
+  } = {}
+): Promise<BundleAnalysis[]> {
+  const {
+    outDir = 'node_modules/.zylaris/deps',
+    format = 'esm',
+    minify = true,
+    sourcemap = true,
+  } = options;
+
+  const results: BundleAnalysis[] = [];
+
+  await fs.mkdir(outDir, { recursive: true });
+
+  for (const dep of deps) {
+    const metadata = await getDependencyMetadata(dep);
+    if (!metadata) continue;
+
+    const outfile = path.join(outDir, `${dep.replace('/', '_')}.js`);
+    const metafile = path.join(outDir, `${dep.replace('/', '_')}.json`);
+
+    // Check if already bundled and up to date
+    if (await isUpToDate(metafile, metadata)) {
+      const cached = await loadCachedAnalysis(metafile);
+      if (cached) {
+        results.push(cached);
+        continue;
+      }
+    }
+
+    try {
+      const result = await build({
+        entryPoints: [metadata.entry],
+        bundle: true,
+        format,
+        outfile,
+        platform: 'browser',
+        target: 'es2022',
+        minify,
+        sourcemap,
+        metafile: true,
+        external: metadata.peerDependencies || [],
+        define: {
+          'process.env.NODE_ENV': '"production"',
+        },
+      });
+
+      const analysis = analyzeMetafile(result.metafile!, metadata.name);
+      results.push(analysis);
+
+      // Cache metadata
+      await fs.writeFile(metafile, JSON.stringify({
+        metadata,
+        analysis,
+        timestamp: Date.now(),
+      }, null, 2));
+
+    } catch (error) {
+      console.warn(`Failed to pre-bundle ${dep}:`, error);
+    }
+  }
+
+  return results;
+}
+
+/** Get dependency metadata */
+async function getDependencyMetadata(name: string): Promise<DepMetadata | null> {
+  try {
+    const pkgPath = require.resolve(`${name}/package.json`, { paths: [process.cwd()] });
+    const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
+
+    return {
+      name: pkg.name,
+      version: pkg.version,
+      entry: pkg.module || pkg.main || 'index.js',
+      browserEntry: pkg.browser,
+      sideEffects: pkg.sideEffects ?? true,
+      peerDependencies: pkg.peerDependencies ? Object.keys(pkg.peerDependencies) : undefined,
+      size: 0, // Will be calculated during bundling
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** Check if cached bundle is up to date */
+async function isUpToDate(metafile: string, metadata: DepMetadata): Promise<boolean> {
+  try {
+    const cached = JSON.parse(await fs.readFile(metafile, 'utf-8'));
+    return cached.metadata.version === metadata.version;
+  } catch {
+    return false;
+  }
+}
+
+/** Load cached analysis */
+async function loadCachedAnalysis(metafile: string): Promise<BundleAnalysis | null> {
+  try {
+    const cached = JSON.parse(await fs.readFile(metafile, 'utf-8'));
+    return cached.analysis;
+  } catch {
+    return null;
+  }
+}
+
+/** Analyze esbuild metafile */
+function analyzeMetafile(metafile: { outputs?: Record<string, { bytes: number; inputs?: Record<string, { bytesInOutput: number }> }> }, _name: string): BundleAnalysis {
+  const outputs = metafile.outputs as Record<string, { bytes: number; inputs?: Record<string, { bytesInOutput: number }> }>;
+  let bundled = 0;
+  const dependencies: string[] = [];
+
+  for (const [file, info] of Object.entries(outputs)) {
+    if (!file.endsWith('.map')) {
+      bundled += info.bytes;
+      
+      // Extract dependencies from inputs
+      if (info.inputs) {
+        for (const input of Object.keys(info.inputs)) {
+          if (input.includes('node_modules')) {
+            const match = input.match(/node_modules\/([^/]+)/);
+            if (match && !dependencies.includes(match[1])) {
+              dependencies.push(match[1]);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return {
+    original: bundled, // Approximation
+    bundled,
+    gzip: 0, // Will be calculated separately
+    dependencies,
+  };
+}
+
+/** Generate optimized import map */
+export async function generateOptimizedImportMap(
+  deps: string[],
+  config: ExternalConfig
+): Promise<Record<string, string>> {
+  const imports: Record<string, string> = {};
+
+  // Pre-bundled deps
+  if (config.prebundle) {
+    const bundled = await prebundleDependencies(config.prebundle);
+    for (const dep of bundled) {
+      imports[dep.dependencies[0]] = `/node_modules/.zylaris/deps/${dep.dependencies[0]}.js`;
+    }
+  }
+
+  // CDN deps
+  if (config.cdn) {
+    for (const dep of deps) {
+      if (!imports[dep]) {
+        imports[dep] = generateCDNUrl(dep, config.cdn);
+      }
+    }
+  }
+
+  return imports;
+}
+
+/** Smart external resolver */
+export function createExternalResolver(
+  config: ExternalConfig = {}
+): (id: string) => boolean {
+  const { external = [], forceInclude = [] } = config;
+
+  return (id: string): boolean => {
+    // Never externalize forced includes
+    if (forceInclude.includes(id)) {
+      return false;
+    }
+
+    // Check explicit externals
+    for (const pattern of external) {
+      if (typeof pattern === 'string') {
+        if (id === pattern || id.startsWith(pattern + '/')) {
+          return true;
+        }
+      } else if (pattern instanceof RegExp) {
+        if (pattern.test(id)) {
+          return true;
+        }
+      }
+    }
+
+    // Default: externalize node_modules
+    if (id.includes('node_modules')) {
+      return true;
+    }
+
+    return false;
+  };
+}
+
+/** Dependency graph analyzer */
+export class DependencyGraph {
+  private graph = new Map<string, Set<string>>();
+
+  async add(modulePath: string): Promise<void> {
+    if (this.graph.has(modulePath)) return;
+
+    const deps = await this.extractImports(modulePath);
+    this.graph.set(modulePath, new Set(deps));
+
+    // Recursively add dependencies
+    for (const dep of deps) {
+      if (!this.isExternal(dep)) {
+        await this.add(dep);
+      }
+    }
+  }
+
+  private async extractImports(modulePath: string): Promise<string[]> {
+    // Simple regex-based extraction (in production, use AST)
+    const content = await fs.readFile(modulePath, 'utf-8');
+    const imports: string[] = [];
+    
+    const importRegex = /import\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"];?/g;
+    let match;
+    
+    while ((match = importRegex.exec(content)) !== null) {
+      const importPath = match[1];
+      if (!importPath.startsWith('.') && !importPath.startsWith('/')) {
+        imports.push(importPath);
+      }
+    }
+
+    return imports;
+  }
+
+  private isExternal(id: string): boolean {
+    return !id.startsWith('.') && !id.startsWith('/');
+  }
+
+  getDependencies(modulePath: string): string[] {
+    const visited = new Set<string>();
+    const result: string[] = [];
+
+    const visit = (path: string) => {
+      if (visited.has(path)) return;
+      visited.add(path);
+
+      const deps = this.graph.get(path);
+      if (deps) {
+        for (const dep of deps) {
+          if (!result.includes(dep)) {
+            result.push(dep);
+          }
+          visit(dep);
+        }
+      }
+    };
+
+    visit(modulePath);
+    return result;
+  }
+
+  findDuplicates(): string[] {
+    const versionMap = new Map<string, string[]>();
+
+    for (const [module] of this.graph) {
+      const name = this.getPackageName(module);
+      if (!versionMap.has(name)) {
+        versionMap.set(name, []);
+      }
+      versionMap.get(name)!.push(module);
+    }
+
+    return Array.from(versionMap.entries())
+      .filter(([_, versions]) => versions.length > 1)
+      .map(([name]) => name);
+  }
+
+  private getPackageName(modulePath: string): string {
+    const match = modulePath.match(/node_modules\/([^/]+)/);
+    return match ? match[1] : modulePath;
+  }
+}
+
+/** Estimate bundle impact */
+export async function estimateBundleImpact(
+  deps: string[]
+): Promise<Array<{ name: string; size: number; gzip: number }>> {
+  const results = await prebundleDependencies(deps, { minify: true });
+  
+  return results.map(r => ({
+    name: r.dependencies[0] || 'unknown',
+    size: r.bundled,
+    gzip: r.gzip,
+  }));
+}
+
+export default {
+  prebundleDependencies,
+  generateOptimizedImportMap,
+  createExternalResolver,
+  DependencyGraph,
+  estimateBundleImpact,
+};