Plugin Configuration

/**
 * Creates legacy browser support plugins for Vite
 * @param options - Configuration options for legacy support
 * @returns Array of three plugins: config, generate-bundle, and post-process
 */
function viteLegacyPlugin(options?: Options): Plugin[];

import { defineConfig } from 'vite';
import legacy from '@vitejs/plugin-legacy';

// Basic usage with default settings
export default defineConfig({
  plugins: [
    legacy(),
  ],
});

// Custom browser targets
export default defineConfig({
  plugins: [
    legacy({
      targets: ['> 1%', 'last 2 versions', 'not dead'],
      modernTargets: ['chrome >= 64', 'firefox >= 67', 'safari >= 12'],
    }),
  ],
});

// Custom polyfills
export default defineConfig({
  plugins: [
    legacy({
      targets: ['IE 11'],
      polyfills: ['es.promise', 'es.array.includes'],
      additionalLegacyPolyfills: ['custom-polyfill'],
    }),
  ],
});

interface TargetsOptions {
  /** 
   * Browser targets for legacy builds using browserslist syntax
   * @default 'last 2 versions and not dead, > 0.3%, Firefox ESR'
   */
  targets?: string | string[] | Record<string, string>;
  
  /** 
   * Browser targets for modern builds using browserslist syntax
   * @default 'edge>=79, firefox>=67, chrome>=64, safari>=12, chromeAndroid>=64, iOS>=12'
   */
  modernTargets?: string | string[];
}

// String format
legacy({
  targets: 'last 2 versions and not dead',
  modernTargets: 'supports es6-module',
});

// Array format
legacy({
  targets: ['> 1%', 'last 2 versions', 'not IE 11'],
  modernTargets: ['chrome >= 64', 'firefox >= 67'],
});

// Object format (for specific versions)
legacy({
  targets: {
    chrome: '58',
    firefox: '57',
    safari: '11',
    edge: '16',
  },
});

interface PolyfillOptions {
  /** 
   * Enable automatic polyfill detection or specify custom polyfills
   * @default true
   */
  polyfills?: boolean | string[];
  
  /** Additional polyfills for legacy builds */
  additionalLegacyPolyfills?: string[];
  
  /** Additional polyfills for modern builds */
  additionalModernPolyfills?: string[];
  
  /** 
   * Modern polyfill configuration for ESM-capable browsers
   * @default false
   */
  modernPolyfills?: boolean | string[];
}

// Automatic polyfill detection (default)
legacy({
  polyfills: true,
});

// Disable polyfills entirely
legacy({
  polyfills: false,
});

// Custom polyfill list
legacy({
  polyfills: ['es.promise.finally', 'es.array.flat'],
  additionalLegacyPolyfills: ['intersection-observer'],
  modernPolyfills: ['es.promise.finally'],
});

interface BuildOptions {
  /** 
   * Generate legacy SystemJS chunks
   * @default true
   */
  renderLegacyChunks?: boolean;
  
  /** 
   * Generate modern ESM chunks
   * @default true
   */
  renderModernChunks?: boolean;
  
  /** 
   * Exclude SystemJS runtime from polyfill chunk
   * @default false
   */
  externalSystemJS?: boolean;
}

// Modern polyfills only (no legacy chunks)
legacy({
  renderLegacyChunks: false,
  modernPolyfills: ['es.promise.finally'],
});

// Legacy only (for file:// protocol compatibility)
legacy({
  renderModernChunks: false,
  targets: ['> 0.5%', 'last 2 versions'],
});

// External SystemJS (reduce bundle size)
legacy({
  externalSystemJS: true,
});

interface AdvancedOptions {
  /** 
   * Babel assumptions for code transformation optimization
   * @see https://babeljs.io/docs/assumptions
   * @default {}
   */
  assumptions?: Record<string, boolean>;
}

// Babel assumptions for smaller output
legacy({
  assumptions: {
    setPublicClassFields: true,
    privateFieldsAsProperties: true,
  },
});

interface Options {
  targets?: string | string[] | Record<string, string>;
  modernTargets?: string | string[];
  polyfills?: boolean | string[];
  additionalLegacyPolyfills?: string[];
  additionalModernPolyfills?: string[];
  modernPolyfills?: boolean | string[];
  renderLegacyChunks?: boolean;
  externalSystemJS?: boolean;
  renderModernChunks?: boolean;
  assumptions?: Record<string, boolean>;
}