Version Utilities

/**
 * Get modules available in specific core-js version
 * @param version - Core-js version string (must be 3.x)
 * @returns Array of module names available in that version
 * @throws RangeError for non-3.x versions
 */
function getModulesListForTargetVersion(version: TargetVersion): readonly ModuleName[];

const { getModulesListForTargetVersion } = require('core-js-compat');

// Get modules for specific version
const v3_30_modules = getModulesListForTargetVersion('3.30.0');
console.log(`${v3_30_modules.length} modules in core-js@3.30.0`);

// Compare versions
const v3_20_modules = getModulesListForTargetVersion('3.20.0');
const newIn3_30 = v3_30_modules.filter(mod => !v3_20_modules.includes(mod));
console.log(`${newIn3_30.length} new modules in 3.30.0:`, newIn3_30);

// Check if module exists in version
function hasModule(moduleName, version) {
  const modules = getModulesListForTargetVersion(version);
  return modules.includes(moduleName);
}

console.log(hasModule('es.array.at', '3.20.0')); // false
console.log(hasModule('es.array.at', '3.30.0')); // true

/**
 * Complete list of all core-js module names
 * Represents all modules available in the latest version
 */
const modules: readonly ModuleName[];

const { modules } = require('core-js-compat');

console.log(`Total modules: ${modules.length}`);

// Filter by category
const esModules = modules.filter(name => name.startsWith('es.'));
const esnextModules = modules.filter(name => name.startsWith('esnext.'));
const webModules = modules.filter(name => name.startsWith('web.'));

console.log(`ES modules: ${esModules.length}`);
console.log(`ESNext modules: ${esnextModules.length}`) ;
console.log(`Web modules: ${webModules.length}`);

// Search modules
function searchModules(pattern) {
  const regex = new RegExp(pattern, 'i');
  return modules.filter(name => regex.test(name));
}

console.log(searchModules('array')); 
// ['es.array.at', 'es.array.concat', 'esnext.array.group', ...]

const { getModulesListForTargetVersion } = require('core-js-compat');

// Track module additions across versions
function getVersionDiff(oldVersion, newVersion) {
  const oldModules = getModulesListForTargetVersion(oldVersion);
  const newModules = getModulesListForTargetVersion(newVersion);
  
  return {
    added: newModules.filter(mod => !oldModules.includes(mod)),
    removed: oldModules.filter(mod => !newModules.includes(mod)),
    oldCount: oldModules.length,
    newCount: newModules.length
  };
}

// Example usage
const diff = getVersionDiff('3.20.0', '3.30.0');
console.log(`Added: ${diff.added.length}, Removed: ${diff.removed.length}`);
console.log('New modules:', diff.added);

// Find minimum version containing required modules
function findMinimumVersion(requiredModules, versions = ['3.20.0', '3.25.0', '3.30.0', '3.35.0', '3.40.0']) {
  for (const version of versions.sort()) {
    const versionModules = getModulesListForTargetVersion(version);
    const hasAll = requiredModules.every(mod => versionModules.includes(mod));
    if (hasAll) return version;
  }
  return null;
}

// Example usage
const required = ['es.array.at', 'es.object.has-own'];
const minVersion = findMinimumVersion(required);
console.log(`Minimum version: ${minVersion}`);

const compat = require('core-js-compat');

// Get compatibility for specific version and targets
function getVersionedCompatibility(version, targets, options = {}) {
  try {
    const result = compat({
      ...options,
      version,
      targets
    });
    
    const versionModules = compat.getModulesListForTargetVersion(version);
    const unavailable = result.list.filter(mod => !versionModules.includes(mod));
    
    return {
      ...result,
      version,
      versionModules: versionModules.length,
      unavailableModules: unavailable
    };
  } catch (error) {
    return { error: error.message };
  }
}

// Example usage
const analysis = getVersionedCompatibility('3.25.0', '> 1%');
if (analysis.unavailableModules?.length > 0) {
  console.log(`Warning: ${analysis.unavailableModules.length} required modules not available in v${analysis.version}`);
}

// Common core-js version milestones
const versionMilestones = {
  '3.0.0': 'Initial 3.x release',
  '3.6.0': 'Major feature additions',
  '3.15.0': 'Proposal standardizations',
  '3.20.0': 'New array methods',
  '3.25.0': 'Iterator helpers',
  '3.30.0': 'Temporal proposals',
  '3.35.0': 'Record & Tuple',
  '3.40.0': 'Decorators support',
  '3.45.0': 'Latest stable features'
};

// Analyze module growth over time
function analyzeVersionGrowth() {
  const versions = Object.keys(versionMilestones).sort();
  const growth = [];
  
  versions.forEach(version => {
    try {
      const modules = getModulesListForTargetVersion(version);
      growth.push({
        version,
        moduleCount: modules.length,
        description: versionMilestones[version]
      });
    } catch (error) {
      // Version not supported
    }
  });
  
  return growth;
}

// Handle version errors gracefully
function safeGetModules(version) {
  try {
    return getModulesListForTargetVersion(version);
  } catch (error) {
    if (error instanceof RangeError) {
      console.error(`Unsupported version: ${version}. Only core-js@3.x is supported.`);
      return null;
    }
    throw error;
  }
}

// Examples of error conditions
console.log(safeGetModules('2.6.12')); // null - unsupported
console.log(safeGetModules('4.0.0'));  // null - unsupported  
console.log(safeGetModules('3.30.0')); // Array of modules - supported

// Optimize bundle for specific core-js version
function optimizeForVersion(targets, maxVersion) {
  const availableModules = getModulesListForTargetVersion(maxVersion);
  
  const result = compat({
    targets,
    modules: availableModules
  });
  
  return {
    ...result,
    optimization: {
      maxVersion,
      availableModules: availableModules.length,
      requiredModules: result.list.length,
      bundleEfficiency: (result.list.length / availableModules.length * 100).toFixed(1) + '%'
    }
  };
}

// Example usage
const optimized = optimizeForVersion('> 1%', '3.30.0');
console.log(optimized.optimization);
// { maxVersion: '3.30.0', availableModules: 340, requiredModules: 85, bundleEfficiency: '25.0%' }

// Plan migration between core-js versions
function planVersionMigration(currentVersion, targetVersion, targets) {
  const currentModules = getModulesListForTargetVersion(currentVersion);
  const targetModules = getModulesListForTargetVersion(targetVersion);
  
  const currentResult = compat({ version: currentVersion, targets });
  const targetResult = compat({ version: targetVersion, targets });
  
  return {
    migration: {
      from: currentVersion,
      to: targetVersion
    },
    changes: {
      newModules: targetModules.filter(mod => !currentModules.includes(mod)),
      removedModules: currentModules.filter(mod => !targetModules.includes(mod)),
      polyfillDiff: targetResult.list.length - currentResult.list.length
    },
    recommendation: targetResult.list.length < currentResult.list.length 
      ? 'Migration will reduce bundle size'
      : 'Migration will increase bundle size but add new features'
  };
}