chore: setup workflows, lints and dependencies

.github/dependabot.yml

@@ -0,0 +1,26 @@
+version: 2
+updates: 
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: monthly
+    groups:
+      github-actions:
+        patterns:
+          - "*"
+  - package-ecosystem: pub
+    directory: /example
+    schedule:
+      interval: monthly
+    groups:
+      example-pub:
+        patterns:
+          - "*"
+  - package-ecosystem: pub
+    directory: /
+    schedule:
+      interval: monthly
+    groups:
+      root-pub:
+        patterns:
+          - "*"

.github/workflows/cached_value.yml

@@ -0,0 +1,31 @@
+name: cached_value
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+on:
+  pull_request:
+    paths:
+      - ".github/workflows/cached_value.yaml"
+      - "lib/**"
+      - "test/**"
+      - "pubspec.yaml"
+  push:
+    branches:
+      - main
+    paths:
+      - ".github/workflows/cached_value.yaml"
+      - "lib/**"
+      - "test/**"
+      - "pubspec.yaml"
+
+jobs:
+  semantic-pull-request:
+    uses: VeryGoodOpenSource/very_good_workflows/.github/workflows/semantic_pull_request.yml@v1
+
+  build:
+    uses: VeryGoodOpenSource/very_good_workflows/.github/workflows/dart_package.yml@v1
+    with:
+      coverage_excludes: '**/*.g.dart'
+      dart_sdk: 'stable'

.gitignore

@@ -73,3 +73,5 @@ build/
 !**/ios/**/default.mode2v3
 !**/ios/**/default.pbxuser
 !**/ios/**/default.perspectivev3
+
+pubspec.lock

analysis_options.yaml

@@ -1,13 +1,11 @@
-include: package:effective_dart/analysis_options.1.3.0.yaml
-
+include: package:very_good_analysis/analysis_options.yaml
 linter:
   rules:
-    - annotate_overrides
-    - await_only_futures
-    - camel_case_types
-    - cancel_subscriptions
-    - close_sinks
-    - comment_references
-    - constant_identifier_names
-    - control_flow_in_finally
-    - empty_statements
+    public_member_api_docs: true
+    one_member_abstracts: false
+
+
+analyzer:
+  exclude:
+    - "**/*.g.dart"
+    - "lib/src/version.dart"

example/example.dart

@@ -1,7 +1,9 @@
+// ignore_for_file: avoid_print
+
 import 'package:cached_value/cached_value.dart';
 
 int factorial(int n) {
-  if (n < 0) throw ('Negative numbers are not allowed.');
+  if (n < 0) throw Exception('Negative numbers are not allowed.');
   return n <= 1 ? 1 : n * factorial(n - 1);
 }
 
@@ -11,9 +13,9 @@ void main() {
 }
 
 void withDependency() {
-  print("with dependency");
+  print('with dependency');
 
-  int originalValue = 1;
+  var originalValue = 1;
   final factorialCache = CachedValue(
     () => factorial(originalValue),
   ).withDependency(
@@ -29,21 +31,21 @@ void withDependency() {
   print(factorialCache.value); // 720
 }
 
-void withTimeToLive() async {
-  print("with TTL:");
+Future<void> withTimeToLive() async {
+  print('with TTL:');
 
-  int originalValue = 1;
+  var originalValue = 1;
   final factorialCache = CachedValue(
     () => factorial(originalValue),
   ).withTimeToLive(
-    lifetime: Duration(seconds: 3),
+    lifetime: const Duration(seconds: 3),
   );
 
   originalValue = 6;
 
   print(factorialCache.value); // 1
 
-  await Future.delayed(Duration(seconds: 3));
+  await Future<void>.delayed(const Duration(seconds: 3));
 
   print(factorialCache.value); // 720
 }

lib/src/cached_value.dart

@@ -1,7 +1,7 @@
-import 'dependent_cached_value.dart';
-import 'simple_cached_value.dart';
-import 'single_child_cached_value.dart';
-import 'time_to_live_cached_value.dart';
+import 'package:cached_value/src/dependent_cached_value.dart';
+import 'package:cached_value/src/simple_cached_value.dart';
+import 'package:cached_value/src/single_child_cached_value.dart';
+import 'package:cached_value/src/time_to_live_cached_value.dart';
 
 /// A signature for functions that computes the value to be cached.
 ///
@@ -28,6 +28,40 @@ typedef ComputeCacheCallback<CacheContentType> = CacheContentType Function();
 /// - [TimeToLiveCachedValue] creates a cache that is invalidated after
 /// some given [Duration].
 abstract class CachedValue<CacheContentType> {
+  /// Creates a [CachedValue] that is only manually invalidated.
+  ///
+  /// The implementation type for the returned value is [SimpleCachedValue].
+  ///
+  /// {@macro simple_cache}
+  ///
+  /// Usage example:
+  /// ```dart
+  /// int factorial(int n) {
+  ///   if (n < 0) throw ('Negative numbers are not allowed.');
+  ///   return n <= 1 ? 1 : n * factorial(n - 1);
+  /// }
+  ///
+  /// int originalValue =1;
+  /// final factorialCache = CachedValue(() => factorial(originalValue));
+  /// print(factorialCache.value); // 1
+  ///
+  /// originalValue = 6;
+  ///
+  /// print(factorialCache.value); // 1
+  /// factorialCache.invalidate();
+  ///
+  /// print(factorialCache.value); // 720
+  /// ```
+  ///
+  /// See also:
+  /// - [DependentCachedValue] creates a cache that is updated if a
+  ///   dependency changes.
+  /// - [TimeToLiveCachedValue] creates a cache that is invalidated after
+  /// some given [Duration].
+  factory CachedValue(ComputeCacheCallback<CacheContentType> callback) {
+    return SimpleCachedValue<CacheContentType>(callback);
+  }
+
   /// Access the current cache value.
   ///
   /// If the cache is considered invalid, calls [refresh].
@@ -74,58 +108,4 @@ abstract class CachedValue<CacheContentType> {
   /// The returned value should be the new cache value.
   /// {@endtemplate}
   CacheContentType refresh();
-
-  /// Creates a [CachedValue] that is only manually invalidated.
-  ///
-  /// The implementation type for the returned value is [SimpleCachedValue].
-  ///
-  /// {@macro simple_cache}
-  ///
-  /// Usage example:
-  /// ```dart
-  /// int factorial(int n) {
-  ///   if (n < 0) throw ('Negative numbers are not allowed.');
-  ///   return n <= 1 ? 1 : n * factorial(n - 1);
-  /// }
-  ///
-  /// int originalValue =1;
-  /// final factorialCache = CachedValue(() => factorial(originalValue));
-  /// print(factorialCache.value); // 1
-  ///
-  /// originalValue = 6;
-  ///
-  /// print(factorialCache.value); // 1
-  /// factorialCache.invalidate();
-  ///
-  /// print(factorialCache.value); // 720
-  /// ```
-  ///
-  /// See also:
-  /// - [DependentCachedValue] creates a cache that is updated if a
-  ///   dependency changes.
-  /// - [TimeToLiveCachedValue] creates a cache that is invalidated after
-  /// some given [Duration].
-  factory CachedValue(ComputeCacheCallback<CacheContentType> callback) {
-    return SimpleCachedValue<CacheContentType>(callback);
-  }
-
-  /// Creates a [CachedValue] that is only manually invalidated.
-  ///
-  /// Use [new CachedValue] instead.
-  @Deprecated('Use the constructor instead')
-  static SimpleCachedValue<CacheContentType> simple<CacheContentType>(
-      ComputeCacheCallback<CacheContentType> callback) {
-    return SimpleCachedValue<CacheContentType>(callback);
-  }
-
-  /// Creates a [CachedValue] that its validity is defined by a dependency.
-  ///
-  /// Use `CachedValue.withDependency` instead.
-  @Deprecated('Use "withDependency" instead')
-  static DependentCachedValue<A, B> dependent<A, B>({
-    required ComputeCacheDependency<B> on,
-    required ComputeCacheCallback<A> compute,
-  }) {
-    return CachedValue<A>(compute).withDependency<B>(on);
-  }
 }

lib/src/dependent_cached_value.dart

@@ -1,8 +1,7 @@
+import 'package:cached_value/src/cached_value.dart';
+import 'package:cached_value/src/single_child_cached_value.dart';
 import 'package:collection/collection.dart';
 
-import 'cached_value.dart';
-import 'single_child_cached_value.dart';
-
 /// A signature for functions that provides dependency of a
 /// [DependentCachedValue].
 ///
@@ -28,6 +27,10 @@ typedef ComputeCacheDependency<DependencyType> = DependencyType Function();
 /// It can be created via `CachedValue.withDependency`
 class DependentCachedValue<CacheContentType, DependencyType>
     extends SingleChildCachedValue<CacheContentType> {
+  DependentCachedValue._(
+    CachedValue<CacheContentType> child,
+    this._getDependency,
+  ) : super(child);
   late DependencyType _dependencyCache = _getDependency();
 
   @override
@@ -44,10 +47,6 @@ class DependentCachedValue<CacheContentType, DependencyType>
 
   final ComputeCacheDependency<DependencyType> _getDependency;
 
-  DependentCachedValue._(
-      CachedValue<CacheContentType> child, this._getDependency)
-      : super(child);
-
   /// {@template dependent_refresh}
   /// Calls refresh on its child and updates the local cache of dependency.
   /// {@endtemplate}
@@ -101,6 +100,15 @@ extension DependentExtension<CacheContentType>
   DependentCachedValue<CacheContentType, DependencyType>
       withDependency<DependencyType>(
     ComputeCacheDependency<DependencyType> on,
-  ) =>
-          DependentCachedValue._(this, on);
+  ) {
+    DependencyType getDependency() {
+      final dependencyValue = on();
+      if (dependencyValue is Iterable && dependencyValue is! List) {
+        return dependencyValue.toList() as DependencyType;
+      }
+      return dependencyValue;
+    }
+
+    return DependentCachedValue._(this, getDependency);
+  }
 }