renovate/lib/modules/datasource/flutter-version/index.ts

import { regEx } from '../../../util/regex.ts';
import { asTimestamp } from '../../../util/timestamp.ts';
import { id as semverId } from '../../versioning/semver/index.ts';
import { Datasource } from '../datasource.ts';
import type { GetReleasesConfig, ReleaseResult } from '../types.ts';
import { FlutterResponse } from './schema.ts';

export const stableVersionRegex = regEx(/^\d+\.\d+\.\d+$/);

export class FlutterVersionDatasource extends Datasource {
  static readonly id = 'flutter-version';

  constructor() {
    super(FlutterVersionDatasource.id);
  }

  override supportsCustomRegistry(_packageName: string): boolean {
    return false;
  }

  override getDefaultRegistryUrls(_packageName: string): string[] {
    return ['https://storage.googleapis.com'];
  }

  override readonly caching = true;

  override readonly defaultVersioning = semverId;

  override readonly releaseTimestampSupport = true;
  override readonly releaseTimestampNote =
    'The release timestamp is determined from the `release_date` field in the results.';
  override readonly sourceUrlSupport = 'package';
  override readonly sourceUrlNote =
    'We use the URL: https://github.com/flutter/flutter.';

  async getReleases({
    registryUrl,
  }: GetReleasesConfig): Promise<ReleaseResult | null> {
    /* v8 ignore next -- should never happen */
    if (!registryUrl) {
      return null;
    }
    const result: ReleaseResult = {
      homepage: 'https://flutter.dev',
      sourceUrl: 'https://github.com/flutter/flutter',
      registryUrl,
      releases: [],
    };
    const resp = await this.fetchJson(
      `${registryUrl}/flutter_infra_release/releases/releases_linux.json`,
      FlutterResponse,
    );
    result.releases = resp.releases
      // The API response contains a stable version being released as a non-stable
      // release. And so we filter out these releases here.
      .filter(({ version, channel }) => {
        if (stableVersionRegex.test(version)) {
          return channel === 'stable';
        }
        return true;
      })
      .map(({ version, release_date, channel }) => ({
        version,
        releaseTimestamp: asTimestamp(release_date),
        isStable: channel === 'stable',
      }));

    return result.releases.length ? result : null;
  }
}