squadron_builder

• Support analyzer versions >=8.2.0.

• Support analyzer versions >=8.0.0.

• Support analyzer versions >=9.0.0 <13.0.0.
• Upgrade squadron to version >=7.4.3.
• Remove generation of elements deleted in Squadron 7.4.3.

• Support analyzer versions >=9.0.0 <11.0.0.

• Support analyzer version 9.0.0.

• When provided in the SquadronService annotation, include the version number as a query parameter to the Worker's URL. See also https://github.com/d-markey/squadron_builder/issues/40.

• Support passing services to other services at construction time, enabling worker cooperation.

• Remove the date/time included in generated comments. Fixes https://github.com/d-markey/squadron_builder/issues/41.

• Upgrade Dart (^3.7.0) + source_gen (^4.0.0) / build (^4.0.0) / analyzer (^8.0.0) packages.

• Fix doc + formatting issues for https://pub.dev/packages/squadron_builder.

• Fix extension lookup in case of cyclical imports/exports -- fixes https://github.com/d-markey/squadron_builder/issues/37.

• Fix warnings from pub.dev.
• Fix discovery of marshalers implemented in extensions.
• Explicitly mention extensions used for marshaling.
• Support toJson/fromJson operating on List and String in addition to Map and dynamic.
• EXPERIMENTAL: use marshalers/jsonifiers for classes covered by extensions targeting parent classes of the target class but not the target class itself. A class may be serialized with some extension and deserialized with another extension. Basic assessment is implemented to locate the best implementation (needs to be improved). For instance:

class A {}
class B extends A {}

extension _MarshalerA on A {
  List marshal(); // used to marshal A and B
  static A unmarshal(List payload); // used to unmarshal back to A
}

extension _UnmarshalerB on B {
  static B unmarshal(List payload); // used to unmarshal back to B
}

• EXPERIMENTAL: search inheritance trees for unmarshalers/jsonifiers. The search will also consider unmarshal/fromJson methods and constructors from higher up in the inheritance tree. In this case, the deserialization method/factory must be aware of possible subtypes (serialization may need to include some information to tell one type vs. the other; see examples in example\inheritance\persons.dart).

• PR #35 (courtesy of https://github.com/mkidv): upgrade to source_gen (^3.0.0) / build (^3.0.1) / analyzer (^7.6.0) packages.

• Update version.

• Fix warnings from pub.dev.

• Rename WorkerAssets.override to override_ to avoid confusion with dart:core's top-level override constant -- fixes https://github.com/d-markey/squadron_builder/issues/34.

• Allow analyzer version above 7.4.0 and ignore deprecation warnings until https://github.com/dart-lang/source_gen/issues/743 and https://github.com/dart-lang/build/issues/3977 are fixed.

• Restrict analyzer version to forbid versions 7.4.0+ as source_gen / build are not compatible with the *2 analyzer APIs yet. Cf. https://github.com/dart-lang/source_gen/issues/743 and https://github.com/dart-lang/build/issues/3977.

• Serialize primary type values as is.
• Remove item type when serializing a list or set -- fixes https://github.com/d-markey/squadron_builder/issues/30.

• Code Generator for Squadron 7.1: stop generating shortcut accessors for stats and concurrency settings.

• Code Generator for Squadron 7.0: generate code for serialization contexts + local workers.

• Set Dart SDK minimum version to 3.6.0.
• Upgrade dependency versions (source_gen --> 2.0.0, analyzers --> 7.1.0).
• Adapt source code where necessary.

• Revert version constraints for packages source_gen and analyzer.

• Update version constraints for package analyzer.

• Update version constraints for package source_gen.
• Implement terminate() in disposable worker/worker pool.
• Update examples.

• Fix pub.dev issues.

• Update serializers/deserializers when Squadron.converter is modified.

• Use marshalers for TypedData.
• Update version number.

• Update version number.

• Don't use marshaller tear-offs when method implementations do not use dynamic (eg. GenericMarshaler<T>.marshal() could be overridden to return something more specific than dynamic).

• Don't generate converters for dynamic or void.
• Use tear-offs instead of lambdas for marshalers where pivot type is dynamic.
• Add support for generating local workers / local worker clients.

• Declare the service activator as const instead of final.

• Make sure no code is emitted when no worker code was generated.

• Update managed type cache asap in handleDartType() (fixes a stack overflow exception).
• Read value of boolean flags in annotations -- fixes https://github.com/d-markey/squadron/issues/44.

• Added log messages.
• Implemented a cache for TypeManagers -- credits go to https://github.com/jpohhhh, thanks!

• Reworked initialization of imported types.

• Do not initialize the type manager before a Squadron annotation is effectively found -- fixes https://github.com/d-markey/squadron/issues/40.

• squadron_builder for Squadron version >= 6.0. Please note there are no versions 3.x-5.x in order to align squadron_builder version numbers with that of Squadron.
• Removed support for 'useLogger' and 'SerializeWith' annotations.
• Added support for libraries imported with a prefix -- fixes https://github.com/d-markey/squadron_builder/issues/14.
• Added support for record types.

• Fix bug for async service method decorated with a marshaler: the service method was called twice if the return value is nullable!

• Remove debug output leftovers.

• Fix bug when generating code for generic service methods -- type arguments were lost in the process.
• Fix bug when a service method argument has no associated element per Dart's analyzer -- such arguments will always be marshalled as-is.
• These two corrections fix https://github.com/d-markey/squadron/issues/26.
• Added example json.

• Fix bug when service method returns FutureOr<void> or Future<void>.
• Make the generated operations map unmodifiable.
• PR #7 by guid-empty: Minor changes to support required fields and fix to have Iterable parameters
• PR #8 by techouse: Allow usage of analyzer v6
• Updated examples.
• Added topics and funding information to pubspec.

• Added example/README.md to comply with pub.dev checks.

• Reorganized example folder and updated README.
• Revised code generation strategy for operations map: previously, the operations map was generated in a mixin class and the (user-developed) service class had to derive from WorkerService and mix in with the generated mixin class. This is no longer required and the generated code now implements a private service class (deriving from the user's service class) which implements WorkerService with the generated operations map. This removes several constraints on service implementation and enables support of "plain old Dart objects" as Squadron services. User-developped service classes must be public and concrete (non-abstract, non-final, non-sealed...) and must provide an unnamed constructor which will be called by the associated generated WorkerService class.
• Service method/constructor parameters whose type implement marshal()/unmarshal() or marshall()/unmarshall() methods will be automatically serialized using these methods if no explicit marshaler is provided. marshal()/unmarshal() have priority over marshall()/unmarshall(). These methods also have priority over automatic JSON serialization available since version 0.9.0. The marshaling method must be an instance method taking no arguments; the unmarshaling method must be static and accept one argument. squadron_builder will not verify parameter or return types of these methods, but obviously if the marshaling method of class T returns type U, the unmarshaling method must accept a U argument and return an instance of T. Failure to comply with this contract may lead to Dart compilation errors.

• Eliminate async code generation for additional assets.
• Properly resolve Squadron's main library.

• Properly handle platform worker thread parameter + getter in generated worker/worker pool when with_finalizers is enabled (fix for https://github.com/d-markey/squadron_builder/issues/5).
• Refactored service/method parameter management.
• Enable code generation for libraries that define several services. This will run as expected on native platforms where worker entrypoints are top-level static methods. It will not work on Web platforms where worker entrypoints are URLs: each worker needs its own URL, hence its own library.

• Automatically discover Squadron capabilities (WorkerRequest/WorkerResponse serialization type + availability of EntryPoint and PlatformWorkerHook).
• Retire option serialization_type as it is now discovered automatically.

• Downgrade version for analyzer (fix for https://github.com/d-markey/squadron_builder/issues/4).

• Downgrade version for analyzer (fix for https://github.com/d-markey/squadron_builder/issues/4).

• Enable support of Dart 3.
• Fix issues reported by pub.dev score.
• Add option serialization_type to configure the serialization type used for worker request/response (Map for Squadron < 5.0.0, List for Squadron >= 5.0.0).

• Breaking changes: several renamings, in particular the builder name which is now squadron_builder:worker_builder.
• Generate appropriate code for fields used as parameters in the constructor of the service class. In previous versions, the generated code for constructors did not map parameters with fields, and fields were overriden with getters/setters throwing an UnimplementedError. Please note that if the field is not final or if its value is mutable, updates will not be propagated to/from the platform worker. This is by design, because the service fields and the worker/pool fields are different instances living in different threads, and threads do not share memory in Dart and browsers.
• Support UseLogger annotation to generate associated code during worther thread initialization.
• Take builder options into account. In previous versions, builder options were ignored. Also upgraded source_gen to 1.3.0 (see pull request https://github.com/dart-lang/source_gen/pull/647 related to builders that produce multiple files).
• Added explicit option with_finalizers to force or disable code generation for finalization, and make finalization actually work.
• Split build.yaml in two to avoid interfering with the build process of client packages.
• Reorganized the source code to make it more readable and maintainable.

• Upgrade packages.
• Switch from deprecated element2/enclosingElement3 to element/enclosingElement.

• Specify platform support in pubspec.yaml.

• Marshal data to/from workers according to SerializeWith annotations.

• Upgrade dependencies.

• Serialize arguments/return values when toJson()/fromJson() is available.

• Annotations SquadronService + SquadronMethod.
• Support of cancellation tokens.
• Package upgrade.
• Sample code.