@_nazmiforreal/flutter-ota 0.1.0 → 0.1.2

package/dart-src/packages/core/lib/src/semver_range.dart

@@ -0,0 +1,358 @@
+/// SemVer range evaluation following node-semver semantics (as verkit).
+///
+/// A range is `||`-separated comparator sets; each set is space-separated
+/// AND-ed comparators. Shorthand (~, ^, x-ranges, partials, hyphen ranges)
+/// is expanded into primitive comparators.
+library;
+
+import 'semver_version.dart';
+
+enum _Op { lt, lte, gt, gte, eq }
+
+class _Comparator {
+  final _Op op;
+  final SemVer version;
+  const _Comparator(this.op, this.version);
+
+  bool test(SemVer v) {
+    switch (op) {
+      case _Op.lt:
+        return v < version;
+      case _Op.lte:
+        return v <= version;
+      case _Op.gt:
+        return v > version;
+      case _Op.gte:
+        return v >= version;
+      case _Op.eq:
+        // Build metadata ignored for equality of ranges.
+        return v.major == version.major &&
+            v.minor == version.minor &&
+            v.patch == version.patch &&
+            v.prerelease.join('.') == version.prerelease.join('.');
+    }
+  }
+
+  /// Whether this comparator explicitly opts a version into prerelease
+  /// testing: same major.minor.patch tuple with its own prerelease set.
+  bool allowsPrereleaseOf(SemVer v) =>
+      version.isPrerelease &&
+      version.major == v.major &&
+      version.minor == v.minor &&
+      version.patch == v.patch;
+
+  @override
+  String toString() => '${_opStr(op)}$version';
+}
+
+String _opStr(_Op o) => switch (o) {
+      _Op.lt => '<',
+      _Op.lte => '<=',
+      _Op.gt => '>',
+      _Op.gte => '>=',
+      _Op.eq => '=',
+    };
+
+final RegExp _xRe = RegExp(r'^[xX*]$');
+
+bool _isX(String? s) => s == null || s.isEmpty || _xRe.hasMatch(s);
+
+/// Expands one raw comparator token into primitives.
+List<_Comparator> _parseToken(String raw) {
+  var t = raw.trim();
+  if (t.isEmpty || t == '*' || t == 'x' || t == 'X') return const [];
+
+  // Strip operator prefix.
+  String op;
+  if (t.startsWith('>=')) {
+    op = '>=';
+    t = t.substring(2);
+  } else if (t.startsWith('<=')) {
+    op = '<=';
+    t = t.substring(2);
+  } else if (t.startsWith('>')) {
+    op = '>';
+    t = t.substring(1);
+  } else if (t.startsWith('<')) {
+    op = '<';
+    t = t.substring(1);
+  } else if (t.startsWith('~')) {
+    op = '~';
+    t = t.substring(1);
+  } else if (t.startsWith('^')) {
+    op = '^';
+    t = t.substring(1);
+  } else {
+    if (t.startsWith('=')) t = t.substring(1);
+    op = '';
+  }
+  t = t.trim();
+
+  final m = RegExp(
+    r'^v?(\d+|x|X|\*)(?:\.(\d+|x|X|\*))?(?:\.(\d+|x|X|\*))?'
+    r'(?:-((?:[0-9A-Za-z-]+)(?:\.[0-9A-Za-z-]+)*))?'
+    r'(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$',
+  ).firstMatch(t);
+  if (m == null) throw FormatException('invalid comparator: $raw');
+
+  final majS = m.group(1)!;
+  final minS = m.group(2);
+  final patS = m.group(3);
+  final preRaw = m.group(4);
+
+  final majIsX = _isX(majS);
+  final minIsX = !majIsX && _isX(minS);
+  final patIsX = !(majIsX || minIsX) && _isX(patS);
+  final hasPre = preRaw != null && preRaw.isNotEmpty;
+
+  SemVer ver(String a, String b, String c, [List<String> pre = const []]) =>
+      SemVer(int.parse(a), int.parse(b), int.parse(c), pre);
+
+  // Full X handling per node-semver replaceXRanges rules.
+  if (majIsX) {
+    return const [_Comparator(_Op.gte, SemVer(0, 0, 0))];
+  }
+
+  final hasMinor = !minIsX;
+  final hasPatch = hasMinor && !patIsX;
+
+  switch (op) {
+    case '':
+    case '=':
+      if (!hasMinor) {
+        return [
+          _Comparator(_Op.gte, ver(majS, '0', '0')),
+          _Comparator(_Op.lt, ver('${int.parse(majS) + 1}', '0', '0')),
+        ];
+      }
+      if (!hasPatch) {
+        return [
+          _Comparator(_Op.gte, ver(majS, minS!, '0')),
+          _Comparator(_Op.lt, ver(majS, '${int.parse(minS) + 1}', '0')),
+        ];
+      }
+      final pre =
+          hasPre ? preRaw.split('.') : const <String>[];
+      return [_Comparator(_Op.eq, ver(majS, minS!, patS!, pre))];
+
+    case '>':
+      if (!hasMinor) {
+        return [_Comparator(_Op.gte, ver('${int.parse(majS) + 1}', '0', '0'))];
+      }
+      if (!hasPatch) {
+        return [
+          _Comparator(_Op.gte, ver(majS, '${int.parse(minS!) + 1}', '0'))
+        ];
+      }
+      return [_Comparator(_Op.gt, ver(majS, minS!, patS!))];
+
+    case '>=':
+      if (!hasMinor) {
+        return [_Comparator(_Op.gte, ver(majS, '0', '0'))];
+      }
+      if (!hasPatch) {
+        return [_Comparator(_Op.gte, ver(majS, minS!, '0'))];
+      }
+      return [
+        _Comparator(_Op.gte, ver(majS, minS!, patS!,
+            hasPre ? preRaw.split('.') : const []))
+      ];
+
+    case '<':
+      if (!hasMinor) {
+        return [_Comparator(_Op.lt, ver(majS, '0', '0'))];
+      }
+      if (!hasPatch) {
+        return [_Comparator(_Op.lt, ver(majS, minS!, '0'))];
+      }
+      return [
+        _Comparator(
+            _Op.lt,
+            ver(majS, minS!, patS!,
+                hasPre ? preRaw.split('.') : const []))
+      ];
+
+    case '<=':
+      if (!hasMinor) {
+        // <=* handled above; here <=N means < N+1.0.0
+        return [_Comparator(_Op.lt, ver('${int.parse(majS) + 1}', '0', '0'))];
+      }
+      if (!hasPatch) {
+        return [
+          _Comparator(_Op.lt, ver(majS, '${int.parse(minS!) + 1}', '0'))
+        ];
+      }
+      return [
+        _Comparator(_Op.lte, ver(majS, minS!, patS!,
+            hasPre ? preRaw.split('.') : const []))
+      ];
+
+    case '~':
+      if (!hasMinor) {
+        return [
+          _Comparator(_Op.gte, ver(majS, '0', '0')),
+          _Comparator(_Op.lt, ver('${int.parse(majS) + 1}', '0', '0')),
+        ];
+      }
+      if (!hasPatch) {
+        return [
+          _Comparator(_Op.gte, ver(majS, minS!, '0')),
+          _Comparator(_Op.lt, ver(majS, '${int.parse(minS) + 1}', '0')),
+        ];
+      }
+      return [
+        _Comparator(
+            _Op.gte,
+            ver(majS, minS!, patS!,
+                hasPre ? preRaw.split('.') : const [])),
+        _Comparator(_Op.lt, ver(majS, '${int.parse(minS) + 1}', '0')),
+      ];
+
+    case '^':
+      if (!hasMinor) {
+        return [
+          _Comparator(_Op.gte, ver(majS, '0', '0')),
+          _Comparator(_Op.lt, ver('${int.parse(majS) + 1}', '0', '0')),
+        ];
+      }
+      if (!hasPatch) {
+        if (int.parse(majS) == 0) {
+          return [
+            _Comparator(_Op.gte, ver('0', minS!, '0')),
+            _Comparator(_Op.lt, ver('0', '${int.parse(minS) + 1}', '0')),
+          ];
+        }
+        return [
+          _Comparator(_Op.gte, ver(majS, minS!, '0')),
+          _Comparator(_Op.lt, ver('${int.parse(majS) + 1}', '0', '0')),
+        ];
+      }
+      final maj = int.parse(majS);
+      final min = int.parse(minS!);
+      final pat = int.parse(patS!);
+      final upper = maj > 0
+          ? SemVer(maj + 1, 0, 0)
+          : (min > 0 ? SemVer(0, min + 1, 0) : SemVer(0, 0, pat + 1));
+      return [
+        _Comparator(_Op.gte,
+            ver(majS, minS, patS, hasPre ? preRaw.split('.') : const [])),
+        _Comparator(_Op.lt, upper),
+      ];
+  }
+  throw StateError('unreachable');
+}
+
+/// Splits a comparator set string into individual comparator tokens,
+/// correctly joining operator prefixes (`>=`, `<=`, `>`, `<`, `~`, `^`, `=`)
+/// with their following version string even when separated by whitespace.
+///
+/// For example, `>= 5.7.0 <= 5.7.4` → `['>= 5.7.0', '<= 5.7.4']`.
+List<String> _splitComparators(String set) {
+  final tokens = <String>[];
+  // Match operator-prefixed comparators first (e.g., ">= 5.7.0"), then bare tokens.
+  final re = RegExp(r'(?:>=|<=|>|<|~|\^|=)\s*\S+|\S+');
+  for (final m in re.allMatches(set)) {
+    tokens.add(m.group(0)!.trim());
+  }
+  return tokens;
+}
+
+List<List<_Comparator>> _parseRange(String range) {
+  final sets = range.trim().split(r'||');
+  final result = <List<_Comparator>>[];
+  for (var set in sets.map((s) => s.trim()).toList()) {
+    if (set.isEmpty) set = '*';
+    // Hyphen ranges first.
+    final hyphenMatch = RegExp(
+            r'^\s*(\S+)\s+-\s+(\S+)\s*$')
+        .firstMatch(set);
+    if (hyphenMatch != null) {
+      final comps = _hyphenToComparators(hyphenMatch.group(1)!,
+          hyphenMatch.group(2)!);
+      result.add(comps);
+      continue;
+    }
+    final comparators = <_Comparator>[];
+    for (final token in _splitComparators(set)) {
+      comparators.addAll(_parseToken(token));
+    }
+    result.add(comparators);
+  }
+  return result;
+}
+
+List<_Comparator> _hyphenToComparators(String leftRaw, String rightRaw) {
+  final out = <_Comparator>[];
+  final fullRe = RegExp(
+    r'^v?(\d+|x|X|\*)(?:\.(\d+|x|X|\*))?(?:\.(\d+|x|X|\*))?'
+    r'(?:-((?:[0-9A-Za-z-]+)(?:\.[0-9A-Za-z-]+)*))?'
+    r'(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$',
+  );
+
+  // Left side: full version (with optional prerelease) -> inclusive lower.
+  final lm = fullRe.firstMatch(leftRaw.trim());
+  if (lm != null) {
+    final maj = lm.group(1)!;
+    final min = lm.group(2);
+    final pat = lm.group(3);
+    final pre = lm.group(4)?.split('.') ?? const <String>[];
+    if (_isX(min)) {
+      out.add(_Comparator(_Op.gte, SemVer(int.parse(maj), 0, 0)));
+    } else if (_isX(pat)) {
+      out.add(
+          _Comparator(_Op.gte, SemVer(int.parse(maj), int.parse(min!), 0)));
+    } else {
+      out.add(_Comparator(_Op.gte,
+          SemVer(int.parse(maj), int.parse(min!), int.parse(pat!), pre)));
+    }
+  }
+
+  // Right side: partial -> exclusive upper bound at next boundary;
+  // full version -> inclusive upper.
+  final rm = fullRe.firstMatch(rightRaw.trim());
+  if (rm != null) {
+    final maj = rm.group(1)!;
+    final min = rm.group(2);
+    final pat = rm.group(3);
+    final pre = rm.group(4)?.split('.') ?? const <String>[];
+    if (_isX(min)) {
+      out.add(_Comparator(_Op.lt, SemVer(int.parse(maj) + 1, 0, 0)));
+    } else if (_isX(pat)) {
+      out.add(_Comparator(
+          _Op.lt, SemVer(int.parse(maj), int.parse(min!) + 1, 0)));
+    } else {
+      out.add(_Comparator(_Op.lte,
+          SemVer(int.parse(maj), int.parse(min!), int.parse(pat!), pre)));
+    }
+  }
+  return out;
+}
+
+/// node-semver `satisfies(version, range)` with default options:
+/// prerelease versions only match when some comparator in the matched set
+/// carries the same major.minor.patch tuple WITH a prerelease.
+bool satisfies(SemVer version, String range) {
+  List<List<_Comparator>> sets;
+  try {
+    sets = _parseRange(range);
+  } on FormatException {
+    return false;
+  }
+  for (final set in sets) {
+    var ok = true;
+    for (final c in set) {
+      if (!c.test(version)) {
+        ok = false;
+        break;
+      }
+    }
+    if (!ok) continue;
+    if (version.isPrerelease) {
+      final allowed =
+          set.any((c) => c.allowsPrereleaseOf(version));
+      if (!allowed) continue;
+    }
+    return true;
+  }
+  return false;
+}

package/dart-src/packages/core/lib/src/semver_version.dart

@@ -0,0 +1,94 @@
+/// SemVer version parsing/comparison following the node-semver conventions
+/// that verkit (hot-updater's semver dependency) implements.
+library;
+
+class SemVer implements Comparable<SemVer> {
+  final int major;
+  final int minor;
+  final int patch;
+  final List<String> prerelease; // identifiers; numeric ones stay numeric-ish
+  final String? build;
+
+  const SemVer(
+    this.major,
+    this.minor,
+    this.patch, [
+    this.prerelease = const [],
+    this.build,
+  ]);
+
+  /// Strict-ish parse; allows partials ("1", "1.2") padded with zeros.
+  /// Returns null on failure.
+  static SemVer? tryParse(String input) {
+    var s = input.trim();
+    if (s.isEmpty) return null;
+    final m = RegExp(
+      r'^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?'
+      r'(?:-((?:[0-9A-Za-z-]+)(?:\.[0-9A-Za-z-]+)*))?'
+      r'(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$',
+    ).firstMatch(s);
+    if (m == null) return null;
+    return SemVer(
+      int.parse(m.group(1)!),
+      int.tryParse(m.group(2) ?? '') ?? 0,
+      int.tryParse(m.group(3) ?? '') ?? 0,
+      m.group(4)?.split('.') ?? const [],
+      m.group(5),
+    );
+  }
+
+  factory SemVer.fromJson(Map<String, dynamic> j) => SemVer(
+        j['major'] as int,
+        j['minor'] as int,
+        j['patch'] as int,
+        (j['prerelease'] as List?)?.map((e) => '$e').toList() ?? const [],
+        j['build'] as String?,
+      );
+
+  bool get isPrerelease => prerelease.isNotEmpty;
+
+  @override
+  String toString() => '$major.$minor.$patch'
+      '${prerelease.isEmpty ? '' : '-${prerelease.join('.')}'}'
+      '${build == null ? '' : '+$build'}';
+
+  @override
+  int compareTo(SemVer o) {
+    final main = [major, minor, patch];
+    final other = [o.major, o.minor, o.patch];
+    for (var i = 0; i < 3; i++) {
+      final c = main[i].compareTo(other[i]);
+      if (c != 0) return c;
+    }
+    // Empty prerelease set > non-empty.
+    if (prerelease.isEmpty && o.prerelease.isEmpty) return 0;
+    if (prerelease.isEmpty) return 1;
+    if (o.prerelease.isEmpty) return -1;
+    for (var i = 0; i < prerelease.length && i < o.prerelease.length; i++) {
+      final c = _compareIdentifier(prerelease[i], o.prerelease[i]);
+      if (c != 0) return c;
+    }
+    return prerelease.length.compareTo(o.prerelease.length);
+  }
+
+  static int _compareIdentifier(String a, String b) {
+    final na = int.tryParse(a);
+    final nb = int.tryParse(b);
+    if (na != null && nb != null) return na.compareTo(nb);
+    if (na != null) return -1; // numeric < alphanumeric
+    if (nb != null) return 1;
+    return a.compareTo(b);
+  }
+
+  @override
+  bool operator ==(Object o) =>
+      o is SemVer && compareTo(o) == 0 && o.build == build;
+
+  @override
+  int get hashCode => Object.hash(major, minor, patch, prerelease);
+
+  bool operator <(SemVer o) => compareTo(o) < 0;
+  bool operator >(SemVer o) => compareTo(o) > 0;
+  bool operator <=(SemVer o) => compareTo(o) <= 0;
+  bool operator >=(SemVer o) => compareTo(o) >= 0;
+}

package/dart-src/packages/core/lib/src/status.dart

@@ -0,0 +1,24 @@
+/// Update status enums — hot-updater `UpdateStatus` / `AppUpdateStatus`.
+library;
+
+enum UpdateStatus {
+  rollback('ROLLBACK'),
+  update('UPDATE');
+
+  final String value;
+  const UpdateStatus(this.value);
+
+  static UpdateStatus fromValue(String v) => UpdateStatus.values
+      .firstWhere((s) => s.value == v,
+          orElse: () => throw ArgumentError('unknown status: $v'));
+}
+
+/// What the client derives: UP_TO_DATE | ROLLBACK | UPDATE.
+enum AppUpdateStatus {
+  upToDate('UP_TO_DATE'),
+  rollback('ROLLBACK'),
+  update('UPDATE');
+
+  final String value;
+  const AppUpdateStatus(this.value);
+}

package/dart-src/packages/core/lib/src/strategy.dart

@@ -0,0 +1,10 @@
+/// Update targeting strategy — hot-updater `UpdateStrategy`.
+library;
+
+enum UpdateStrategy {
+  fingerprint('fingerprint'),
+  appVersion('appVersion');
+
+  final String value;
+  const UpdateStrategy(this.value);
+}

package/dart-src/packages/core/lib/src/update_bundle_params.dart

@@ -0,0 +1,30 @@
+import 'platform.dart';
+
+/// hot-updater `UpdateBundleParams` — device-side parameters sent with
+/// update requests.
+class UpdateBundleParams {
+  final Platform platform;
+  final String bundleId;
+  final String minBundleId;
+  final String channel;
+  final String appVersion;
+  final String? fingerprintHash;
+
+  const UpdateBundleParams({
+    required this.platform,
+    required this.bundleId,
+    required this.minBundleId,
+    required this.channel,
+    required this.appVersion,
+    required this.fingerprintHash,
+  });
+
+  Map<String, dynamic> toJson() => {
+        'platform': platform.value,
+        'bundleId': bundleId,
+        'minBundleId': minBundleId,
+        'channel': channel,
+        'appVersion': appVersion,
+        if (fingerprintHash != null) 'fingerprintHash': fingerprintHash,
+      };
+}

package/dart-src/packages/core/lib/src/uuid.dart

@@ -0,0 +1,45 @@
+/// UUID helpers matching hot-updater semantics.
+///
+/// Bundle ids are UUIDv7 (time-sortable); hot-updater relies on lexicographic
+/// ordering of the string form matching chronological order.
+library;
+
+import 'dart:math';
+
+const String nilUuid = '00000000-0000-0000-0000-000000000000';
+
+final RegExp _uuidV7Pattern = RegExp(
+  r'^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$',
+);
+
+final Random _random = Random.secure();
+
+String _hex(int value, int width) =>
+    value.toRadixString(16).padLeft(width, '0');
+
+/// Generates a lowercase RFC 9562 UUIDv7 string (unix-ms timestamp based).
+String uuidV7({DateTime? now}) {
+  final ts = (now ?? DateTime.now()).millisecondsSinceEpoch;
+  if (ts < 0 || ts > 0xFFFFFFFFFFFF) {
+    throw ArgumentError('timestamp out of UUIDv7 range');
+  }
+  // Layout: 48-bit ts | ver(0101)+12 rand bits | var(10)+62 rand bits.
+  // Groups: 8 - 4 - "7"+3 - 2(var)+2 - 12.
+  final rand = List.generate(10, (_) => _random.nextInt(256));
+  final tsHex = _hex(ts, 12);
+  final g3 = '${_hex(rand[0] & 0x0F, 1)}${_hex(rand[1], 2)}';
+  final g4 =
+      '${_hex((rand[2] & 0x3F) | 0x80, 2)}${_hex(rand[3], 2)}';
+  final g5 = StringBuffer();
+  for (var i = 4; i < 10; i++) {
+    g5.write(_hex(rand[i], 2));
+  }
+  return '${tsHex.substring(0, 8)}-'
+      '${tsHex.substring(8, 12)}-'
+      '7$g3-$g4-$g5';
+}
+
+bool isUuidV7(String value) => _uuidV7Pattern.hasMatch(value);
+
+/// Lexicographic comparison used by hot-updater for bundle ordering.
+int compareBundleIds(String a, String b) => a.compareTo(b);

package/dart-src/packages/core/pubspec.yaml

@@ -0,0 +1,9 @@
+name: flutter_patcher_core
+description: Core data model, rollout cohorts, and shared utilities for flutter_patcher — Dart translation of hot-updater's packages/core.
+version: 0.1.0
+publish_to: none
+
+environment:
+  sdk: '>=3.0.0 <4.0.0'
+dev_dependencies:
+  test: ^1.31.2

package/dart-src/packages/core/tool/dbg.dart

@@ -0,0 +1,6 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart';
+void main() {
+  // ignore: avoid_print
+  print('coerce=${semverCoerce('app version 2.3.6!')}');
+  print('sat=${satisfies(const SemVer(2, 3, 6), '~2.3.4')}');
+}

package/dart-src/plugins/aws/lib/flutter_patcher_aws.dart

@@ -0,0 +1,12 @@
+export 'src/aws_storage.dart' show s3Storage;
+export 'src/aws_database.dart'
+    show S3DatabaseConfig, s3Database, defaultAwsS3DatabaseClientFactory, defaultAwsCloudFrontClientFactory;
+export 'src/aws_config.dart' show AwsS3StorageConfig, defaultAwsS3ClientFactory;
+export 'src/aws_s3_client.dart' show AwsS3ClientLike;
+export 'src/aws_cloudfront_client.dart' show AwsCloudFrontClientLike;
+export 'src/aws_cloudfront_signer.dart'
+    show cloudfrontSignedUrl, verifyCloudfrontSignedUrl;
+export 'src/with_cloudfront_signed_url.dart'
+    show WithCloudFrontSignedUrlOptions, withCloudFrontSignedUrl;
+export 'src/aws_lambda_edge_storage.dart'
+    show AwsLambdaEdgeStorageConfig, awsLambdaEdgeStorage, s3LambdaEdgeStorage;