Skip to content
Snippets Groups Projects
Select Git revision
  • 497d4c131fd341b9b72c9a0cefc87034e51bd226
  • main default protected
  • next
  • fix/36615b-branch-reuse-no-cache
  • renovate/main-redis-5.x
  • chore/punycode
  • refactor/pin-new-value
  • feat/36219--git-x509-signing
  • feat/structured-logger
  • hotfix/39.264.1
  • feat/skip-dangling
  • gh-readonly-queue/next/pr-36034-7a061c4ca1024a19e2c295d773d9642625d1c2be
  • hotfix/39.238.3
  • refactor/gitlab-auto-approve
  • feat/template-strings
  • gh-readonly-queue/next/pr-35654-137d934242c784e0c45d4b957362214f0eade1d7
  • fix/32307-global-extends-merging
  • fix/32307-global-extends-repositories
  • gh-readonly-queue/next/pr-35009-046ebf7cb84ab859f7fefceb5fa53a54ce9736f8
  • gh-readonly-queue/next/pr-35009-9d5e583b7d7251148ab0d11ee8dd38149618d162
  • gh-readonly-queue/next/pr-35009-a70e4ea7c6484aef873585a7f22ee2f796c58cb5
  • 41.42.9
  • 41.42.8
  • 41.42.7
  • 41.42.6
  • 41.42.5
  • 41.42.4
  • 41.42.3
  • 41.42.2
  • 41.42.1
  • 41.42.0
  • 41.41.0
  • 41.40.0
  • 41.39.0
  • 41.38.2
  • 41.38.1
  • 41.38.0
  • 41.37.12
  • 41.37.11
  • 41.37.10
  • 41.37.9
41 results

index.ts

Blame
  • user avatar
    Rhys Arkins authored
    Changes `rangeStrategy` default value from `'replace'` to `'auto'`. Also changes `auto` behavior so that `update-lockfile` is preferred if the manager
    supports the `updateLockedDependency()` function.
    
    Closes #19800
    
    BREAKING CHANGE: Renovate will now default to updating locked dependency versions. To revert to previous behavior, configure rangeStrategy=replace.
    016e6473
    History
    index.ts 2.73 KiB
    import { programmingLanguages } from '../../constants';
    import type { RangeStrategy } from '../../types';
    import managers from './api';
    import type {
      ExtractConfig,
      GlobalManagerConfig,
      ManagerApi,
      PackageFile,
      PackageFileContent,
      RangeConfig,
      Result,
    } from './types';
    export { hashMap } from './fingerprint.generated';
    const managerList = Array.from(managers.keys());
    
    const languageList = programmingLanguages.concat();
    
    export function get<T extends keyof ManagerApi>(
      manager: string,
      name: T
    ): ManagerApi[T] | undefined {
      return managers.get(manager)?.[name];
    }
    export const getLanguageList = (): string[] => languageList;
    export const getManagerList = (): string[] => managerList;
    export const getManagers = (): Map<string, ManagerApi> => managers;
    
    export async function detectAllGlobalConfig(): Promise<GlobalManagerConfig> {
      let config: GlobalManagerConfig = {};
      for (const managerName of managerList) {
        const manager = managers.get(managerName)!;
        if (manager.detectGlobalConfig) {
          // This should use mergeChildConfig once more than one manager is supported, but introduces a cyclic dependency
          config = { ...config, ...(await manager.detectGlobalConfig()) };
        }
      }
      return config;
    }
    
    export async function extractAllPackageFiles(
      manager: string,
      config: ExtractConfig,
      files: string[]
    ): Promise<PackageFile[] | null> {
      if (!managers.has(manager)) {
        return null;
      }
      const m = managers.get(manager)!;
      if (m.extractAllPackageFiles) {
        const res = await m.extractAllPackageFiles(config, files);
        // istanbul ignore if
        if (!res) {
          return null;
        }
        return res;
      }
      return null;
    }
    
    export function extractPackageFile(
      manager: string,
      content: string,
      fileName: string,
      config: ExtractConfig
    ): Result<PackageFileContent | null> {
      if (!managers.has(manager)) {
        return null;
      }
      const m = managers.get(manager)!;
      return m.extractPackageFile
        ? m.extractPackageFile(content, fileName, config)
        : null;
    }
    
    export function getRangeStrategy(config: RangeConfig): RangeStrategy | null {
      const { manager, rangeStrategy } = config;
      if (!manager || !managers.has(manager)) {
        return null;
      }
      const m = managers.get(manager)!;
      if (m.getRangeStrategy) {
        // Use manager's own function if it exists
        const managerRangeStrategy = m.getRangeStrategy(config);
        if (managerRangeStrategy === 'in-range-only') {
          return 'update-lockfile';
        }
        return managerRangeStrategy;
      }
      if (rangeStrategy === 'auto') {
        if (m.updateLockedDependency) {
          return 'update-lockfile';
        }
        // default to 'replace' for auto
        return 'replace';
      }
      if (rangeStrategy === 'in-range-only') {
        return 'update-lockfile';
      }
    
      return config.rangeStrategy;
    }