rrousselgit / freezed Goto Github PK

@immutable
abstract class Either<L, R> with _$Either<L, R> {
  const factory Either.left(L left) = Left;
  const factory Either.right(R right) = Right;
}

void run(Either<int, String> either) {
  either.when(left: (value) => print(value), right: (value) => value);
}
---
run(Left(10));

part of 'sign_in_form_bloc.dart';

@immutable
abstract class SignInFormEvent with _$SignInFormEvent {
  const factory SignInFormEvent.emailChanged(String emailStr) = _EmailChanged;
  const factory SignInFormEvent.passwordChanged(String passwordStr) =
      _PasswordChanged;
}

import 'package:flutter/foundation.dart';

part 'sign_in_form_event.dart';
part 'sign_in_form_state.dart';

part 'sign_in_form_bloc.freezed.dart';

class SignInFormBloc extends Bloc<SignInFormEvent, SignInFormState> {...}

import 'package:flutter/foundation.dart';

part 'sign_in_form_event.freezed.dart';

@immutable
abstract class SignInFormEvent with _$SignInFormEvent {
  const factory SignInFormEvent.emailChanged(String emailStr) = _EmailChanged;
  const factory SignInFormEvent.passwordChanged(String passwordStr) =
      _PasswordChanged;
}

@immutable
abstract class Complete<Params, Value> with _$Complete {
  const factory Complete.success(Params params, Value value) = Success;
  const factory Complete.error(Params params, Object error) = Error;
}

/// *.freezed.dart

'Error.copyWith' ('Error<Params, Value> Function({error: Object, params: Params})') isn't a valid override of '_$Complete.copyWith' ('Complete<dynamic, dynamic> Function({params: dynamic})').dart(invalid_override)

'Success.copyWith' ('Success<Params, Value> Function({params: Params, value: Value})') isn't a valid override of '_$Complete.copyWith' ('Complete<dynamic, dynamic> Function({params: dynamic})').dart(invalid_override)

onError: (err) => MyClass.error(err),

onError: $MyClass.error,

abstract class AppState {}
abstract class AppNavigationState {}
class AppNavigateToAState extends AppState with AppNavigationState {}
class AppNavigateToBState extends AppState with AppNavigationState {}
class AppSomeOtherState extends AppState {}

.appBloc.whereType<AppNavigationState>()

abstract class AppNavigationState {}

@freezed
abstract class AppState with _$Union {
  @freezedWith(AppNavigationState)
  const factory AppState.navigateToA() = NavigateToA;
  @freezedWith(AppNavigationState)
  const factory AppState.navigateToB() = NavigateToB;
}

import 'package:freezed_annotation/freezed_annotation.dart';
part 'second_state.freezed.dart';
part 'second_state.g.dart';

@freezed
abstract class SecondState with _$SecondState {
  const factory SecondState({
    @JsonKey(ignore: true, nullable: true) String dateTime,
    @JsonKey(ignore: true, nullable: true) String uuid,
  }) = _SecondState;

  const factory SecondState.fromJson(Map<String, dynamic> json) => _$SecondStateFromJson(json);
}

abstract class Example with _$Example {
  factory Example(@JsonKey(name: 'whatever') String value) = _Example;
}

  factory Model.fromJson(Map<String, dynamic> json) => _$ModelFromJson(json);

@immutable
abstract class Foo with _$Foo {
  factory Foo(RedirectedName value) = RedirectedName; 
}

@immutable
abstract class PriceExample with _$PriceExample {
  const factory PriceExample.price(
    int id,
    int price,
  ) = Price;

  const factory PriceExample.withQuantity(
    Price price,
    int quantity,
  ) = PriceWithQuantity;
}

@immutable
abstract class Person with _$Person {
  const factory Person(String firstName, String lastName) = _Person;

  String get fullName => '$firstName $lastName';
}

@immutable
abstract class ClubId with _$ClubId {
  const factory ClubId(String value) = _ClubIdDataClass;

  @override
  String toString() {
    return 'ClubId#$value';
  }
}

class Person{
  final String name;
  final int age;
  final double height;
  final int personId;

  const Person(this.name, this.age, this.height, this.personId);

  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
          other is Person &&
              runtimeType == other.runtimeType &&
              name == other.name &&
              age == other.age &&
              height == other.height &&
              personId == other.personId;

  @override
  int get hashCode =>
      name.hashCode ^
      age.hashCode ^
      height.hashCode ^
      personId.hashCode;
  
}

class Person{
  final String name;
  final int age;
  final double height;
  final int personId;

  const Person(this.name, this.age, this.height, this.personId);

  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
          other is Person &&
              runtimeType == other.runtimeType &&
              personId == other.personId;

  @override
  int get hashCode => personId.hashCode;
}

@immutable
abstract class TodoList with _$TodoList {
  factory TodoList.data(List<Todo> todos) = TodoListData;
  factory TodoList.loading(List<Todo> todos) = TodoListLoading;
  factory TodoList.error(List<Todo> todos, [String message]) = TodoListError;
}

var todo = TodoList.data([]);
todo = TodoList.loading(todo.todos);
todo = TodoList.error(toto.todos, 'Error');

var todo = TodoList.data([]);

todo = todo.copyAsLoading();
todo = todo.copyAsError(message: 'Error');

@immutable
abstract class Example with _$Example {
  factory Example({@deprecated String value}) = _Example;
}

@immutable
abstract class AuthState with _$AuthState {
    const factory AuthState.authorized(User user) = _AuthStateAuthorized;
    const factory AuthState.unauthorized() = _AuthStateUnauthorized;
}

// Some logic which needs user to be authorized
if (!authState.isAuthorized) return;

final authorizedState = authState.asAuthorized; // Returns authState as _AuthStateAuthorized

@freezed
abstract class Example with _$Example {
  @deprecated
  factory Example() = GeneratedClass;
}

@deprecated
class GeneratedClass {
...
}

import 'package:flutter/foundation.dart';
import 'package:freezed_annotation/freezed_annotation.dart';

part 'test.freezed.dart';
part 'test.g.dart';

@freezed
abstract class Test with _$Test{

  const factory Test() = _Test;

  static int get value => 0;
}

@freezed
abstract class Union with _$Union {
  const factory Union.loaded(@freezedToString((i) => i.length) List<Item> items) = Loaded;
  const factory Union.loading() = Loading;
}

@freezedNoToString
abstract class ClubId with _$ClubId {
  const factory ClubId(String value) = _ClubIdDataClass;

  @override
  String toString() {
    return 'ClubId#$value';
  }
}

/// model.dart

import 'package:json_annotation/json_annotation.dart';
import 'package:flutter/foundation.dart';

part 'model.freezed.dart';
part 'model.g.dart';

@immutable
abstract class Parent<T> with _$Parent<T> {
  const factory Parent(@DataConverter() List<T> items) = _Parent<T>;

  factory Parent.fromJson(Map<String, dynamic> json) =>
      _$ParentFromJson<T>(json);
}

@immutable
abstract class Item with _$Item {
  const factory Item(String name) = _Item;

  factory Item.fromJson(Map<String, dynamic> json) => _$ItemFromJson(json);
}

class DataConverter<T> implements JsonConverter<T, Object> {
  const DataConverter();

  @override
  T fromJson(Object json) {
    return Item.fromJson(json) as T;
  }

  @override
  Object toJson(T object) {
    return object;
  }
}

lib/model.freezed.dart:74:57: Error: The constructor function type '_$_Parent<dynamic> Function(Map<String, dynamic>)' isn't a subtype of '_Parent<T> Function(Map<String, dynamic>)'.
 - '_$_Parent' is from 'package:freezed_test/model.dart' ('lib/model.dart').
 - 'Map' is from 'dart:core'.
 - '_Parent' is from 'package:freezed_test/model.dart' ('lib/model.dart').
  factory _Parent.fromJson(Map<String, dynamic> json) = _$_Parent.fromJson;

/// model.freezed.dart:74

factory _Parent.fromJson(Map<String, dynamic> json) = _$_Parent.fromJson;
to
factory _Parent.fromJson(Map<String, dynamic> json) = _$_Parent<T>.fromJson;

@freezed
abstract class Data with _$Data {
  factory Data({
    List<String> keys,
  }) = _Data;
}

void main() {
  test("test", () {
    Data buildItem() {
      return Data(keys: ["VALUE"]);
    }

    final data1 = buildItem();
    final data2 = buildItem();

    expect(data1, equals(data2));
    expect(data1.hashCode, equals(data2.hashCode));
  });
}

@JsonSerializable()
class Response<T>{
int status;
T data;

Response(this.status,this.data);

factory Response.fromJson(Map<String, dynamic> json) =>
 _$ResponseFromJson(json);

  Map<String, dynamic> toJson() => _$ResponseToJson(this);    
}

@JsonSerializable()
class PersonResponse {
  Person person;

  PersonResponse(this.person);

  factory PersonResponse.fromJson(Map<String, dynamic> json) =>
      _$PersonResponseFromJson(json);

  Map<String, dynamic> toJson() => _$PersonResponseToJson(this);
}

@JsonSerializable()
class PeopleResponse {
  final int count;
  final List<Person> people;

  PeopleResponse(this.count, this.people);

  factory PeopleResponse.fromJson(Map<String, dynamic> json) =>
      _$PeopleResponseFromJson(json);

  Map<String, dynamic> toJson() => _$PeopleResponseToJson(this);
}

@JsonSerializable()
class Person {
 String name ;
 int age; 

 Person(this.name,this.age);  

 factory Person.fromJson(Map<String, dynamic> json) =>
 _$PersonFromJson(json);

 Map<String, dynamic> toJson() => _$PersonToJson(this); 
}

class DataConverter<T> implements JsonConverter<T, Object>{
  const DataConverter();

  @override
  T fromJson(Object json) {
    final data = json as Map<String, dynamic>;
    if (data.containsKey('person')) {
      return PersonResponse.fromJson(data) as T;
    }
    return PeopleResponse.fromJson(data) as T;
  }

  @override
  Object toJson(T object) {
    if (object is PersonResponse) {
      return object.toJson();
    }
    return (object as PeoplePayload).toJson();
  }
}

@JsonSerializable()
class Response<T> {
  int status;
  @DataConverter() // <--- custom converter annotation
  T data;

  Response(this.status, this.data);

  factory Response.fromJson(Map<String, dynamic> json) =>
      _$ResponseFromJson(json);

  Map<String, dynamic> toJson() => _$ResponseToJson(this);
}

@immutable
class Response<T>{
    factory Response(
    int status,
    @DataConverter() T data, // <--- custom converter annotation
    ) = _Response;

    factory Response.fromJson(Map<String, dynamic> json) => _$ResponseFromJson(json);
}

// main.dart
import 'package:flutter/foundation.dart';
import 'package:json_annotation/json_annotation.dart';

part 'model.freezed.dart';
part 'model.g.dart';

@immutable
abstract class Model with _$Model {
  factory Model({String a, List<Model> models}) = _Model;

  factory Model.fromJson(Map<String, dynamic> json) => _$ModelFromJson(json);
}

main() {
  var model = Model(
    a: 'hol',
    models: [
      Model(
        a: 'no',
        models: const [],
      ),
    ],
  );

  model.copyWith(a: 't'); // => no
}

@immutable
abstract class Example with _$Example {
  const factory Example(String a, {int b}) = Example0;

  factory Example.fixed() {
    return const Example('a', b: 42);
  }
}

@freezed
abstract class DefaultList
    with _$DefaultList {
  const factory DefaultList(
      {@Default(<String>[]) List<String> values,}) = _DefaultList;
}

class _$_DefaultList with DiagnosticableTreeMixin implements _DefaultList {
  const _$_DefaultList({@Default(<String>[]) this.values = <String>[] // <- this should be const!
 }); 
...

@JsonSerializable(fieldRename: FieldRename.snake)
class Person {
 // will convert camal case to snake case automatically 
//  equivelant to JsonKey(name:"first_name")
  String firstName;
}

@SerializableFreezed(fieldRename: FieldRename.snake)
class Person {
  factory Person(String firstName) = _Person;
}

abstract class Example with _$Example {
  factory Example(@Default(42) int value) = _Example;
}

@JsonKey(defaultValue: 42)

part 'union.freezed.dart';

@immutable
abstract class Union<T> with _$Union<T> {
  const factory Union(List<T> value) = Data<T>;
  const factory Union.apiError(WebException webException) = ApiErrorDetails<T>;
  const factory Union.connectionError() = ConnectionErrorDetails<T>;
}

@freezed
abstract class Todo with _$Todo {
  factory Todo(String task, {bool complete, String note, String id}) = _Todo;

  factory Todo fromEntity(TodoEntity entity) {
    return Todo(
      entity.task,
      complete: entity.complete ?? false,
      note: entity.note,
      id: entity.id,
    );
  }
}

extension TodoToEntity on Todo {
  TodoEntity toEntity() {
    return TodoEntity(task, id, note, complete);
  }
}

@freezed
abstract class Todo with _$Todo {
  factory Todo(String task, {bool complete, String note, String id}) = _Todo;

  factory Todo.fromEntity(TodoEntity entity) => _$TodoFromEntity(entity);
}

Planets _$PlanetsFromJson(Map<String, dynamic> json) {
  assert(json['runtimeType'] is String);
  switch (json['runtimeType'] as String) {
    case 'default':
      return _Planets.fromJson(json);

    default:
      throw FallThroughError();
  }
}