Class Modifiers

// Your library
class Listenable {
  void addListener(VoidCallback listener) { /* ... */ }
  void removeListener(VoidCallback listener) { /* ... */ }
}

// User"s library
class MyListenable extends Listenable {
  @override
  void addListener(VoidCallback listener) {
    // Breaks your invariant — skips registration
  }
}

interface class Listenable {
  void addListener(VoidCallback listener);
  void removeListener(VoidCallback listener);
}

// User's library
class MyListenable extends Listenable {} // COMPILE ERROR
class MyListenable implements Listenable {
  // Must provide ALL methods — no inherited behavior to break
  @override
  void addListener(VoidCallback listener) { /* ... */ }
  @override
  void removeListener(VoidCallback listener) { /* ... */ }
}

// Only files in this library (and its part files) can subtype Node
sealed class Node {}

class Element extends Node { /* ... */ }
class Text extends Node { /* ... */ }

// Another library:
// class Comment extends Node {} // COMPILE ERROR

// Your library
base class Shape {
  void draw() { /* base implementation */ }
  int get area;
}

// User's library — same package, different library
import 'shapes.dart';

// OK — extends, inherits behavior
class Circle extends Shape {
  @override
  int get area => pi * radius * radius;
}

// COMPILE ERROR — cannot implement a base class
class Square implements Shape {
  @override
  void draw() { /* user's implementation */ }
  @override
  int get area => side * side;
}

// Your library — designed for extension
base class Resource {
  bool _isInitialized = false;

  void initialize() {
    _doSetup();
    _isInitialized = true;
  }

  void use() {
    if (!_isInitialized) throw StateError('Not initialized');
    _doWork();
  }

  void _doSetup() { /* ... */ }
  void _doWork() { /* ... */ }
}

// User's library
// Without 'base', user could do this:
class MyResource implements Resource {
  @override
  void initialize() { /* user skips your setup */ }
  @override
  void use() { /* no initialization check — invariant broken */ }
}

// With 'base', user MUST extend — they get your invariant checks
class MyResource extends Resource {
  // They override specific behavior but your invariant enforcement remains
  @override
  void _doWork() { /* custom work */ }
}

base class Animal {
  void speak() => print('...');
}

// Dog is effectively base — cannot be implemented externally
class Dog extends Animal {
  @override
  void speak() => print('Woof');
}

// External library:
// class MyPet implements Dog {} // COMPILE ERROR
// class MyPet extends Dog {} // OK

base mixin Validatable {
  bool validate();
}

// External code can only use this via 'with' on a class that extends a base class
// They cannot 'implements' it (which would bypass the mixin's super calls)

// Your library
interface class Serializable {
  Map<String, dynamic> toJson();
  static Serializable fromJson(Map<String, dynamic> json) =>
    throw UnsupportedError('Subclass must implement');
}

// User's library
// COMPILE ERROR — cannot extend an interface class
class User extends Serializable {}

// OK — implements, provides own behavior
class User implements Serializable {
  final String name;
  User(this.name);

  @override
  Map<String, dynamic> toJson() => {'name': name};
}

// Pure contract — no behavior to inherit
interface class Hashable {
  int get hashCode;
}

// If this were a regular class, users could extend it and accidentally
// depend on implementation details that might change between versions.
// With 'interface', they must provide their own hashCode.

interface class Loggable {
  void log(String message) => print('[${DateTime.now()}] $message');
  void error(String message) {
    log('ERROR: $message');
  }
}

// Same library — can extend (inherits log/error)
class Service extends Loggable {
  void doWork() => log('Working...');
}

// External library — must implement (provides own log/error)
class ExternalService implements Loggable {
  @override
  void log(String message) => logger.info(message);
  @override
  void error(String message) => logger.error(message);
}

interface mixin Disposable {
  void dispose();
}

// External code must 'implements', not 'with' (no inherited behavior)

// Your library
final class ImmutableConfig {
  final String host;
  final int port;
  const ImmutableConfig(this.host, this.port);
}

// User's library — all of these are COMPILE ERRORS:
// class MyConfig extends ImmutableConfig {}
// class MyConfig implements ImmutableConfig {}
// class MyThing with ImmutableConfig {}

// The only way to use ImmutableConfig is to instantiate it or reference it
final config = ImmutableConfig('localhost', 8080);

// Value object — should never be extended
final class UserId {
  final String value;
  const UserId(this.value);

  @override
  bool operator ==(Object other) =>
    identical(this, other) || other is UserId && value == other.value;

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

final class Base {
  // ...
}

// Same library — extending a final class is allowed
class Derived extends Base {
  // Derived is NOT final — external code can extend Derived
}

// External library:
class ExternalDerived extends Derived {} // OK

final mixin class Singleton {
  static final Singleton _instance = Singleton._internal();
  Singleton._internal();
  factory Singleton() => _instance;
}

// External code cannot extend, implement, or mix in Singleton

mixin class Hoverable {
  bool _isHovered = false;

  void onEnter() => _isHovered = true;
  void onLeave() => _isHovered = false;
  bool get isHovered => _isHovered;
}

// Used as a class (extends)
class Button extends Hoverable {
  void click() {
    if (isHovered) print('Clicked while hovered');
  }
}

// Used as a mixin (with)
class Link extends Object with Hoverable {
  final String url;
  Link(this.url);
}

// OK — no constructor or parameterless constructor
mixin class A {
  A();
}

// COMPILE ERROR — mixins cannot have parameterized constructors
mixin class B {
  final int value;
  B(this.value); // ERROR when used as 'with'
}

// But B CAN be extended (classes can have constructors)
class C extends B {
  C(int value) : super(value);
}

// D cannot use B as a mixin because B has a parameterized constructor
// class D extends Object with B {} // COMPILE ERROR

base mixin class Observable {
  final List<VoidCallback> _listeners = [];

  void addListener(VoidCallback listener) => _listeners.add(listener);
  void removeListener(VoidCallback listener) => _listeners.remove(listener);
  void notifyListeners() => _listeners.forEach((cb) => cb());
}

// External code can extend or use as mixin, but cannot implement
class Button extends Observable {}
class Slider extends Object with Observable {}
// class Checkbox implements Observable {} // COMPILE ERROR

sealed interface class Node {
  // Can be extended or implemented within the same library only
  // External code cannot use Node at all (except as a type reference)
}

base mixin Persistable {
  void save(String path);
  void load(String path);
}

// External: must extend (not implement)
class Database extends Object with Persistable {
  @override
  void save(String path) { /* ... */ }
  @override
  void load(String path) { /* ... */ }
}

final mixin class AtomicCounter {
  int _count = 0;
  int get count => _count;
  void increment() => _count++;
}

// External code cannot do ANYTHING with this except instantiate it
final counter = AtomicCounter();
counter.increment();

interface mixin Comparable<T> {
  int compareTo(T other);
}

// External: must implement (no inherited behavior, no extension)
class Version implements Comparable<Version> {
  @override
  int compareTo(Version other) => /* ... */;
}

// Before: unrestricted
abstract class Widget {
  Widget build(BuildContext context);
}

// After: base — prevents implements, requires extends
base class Widget {
  Widget build(BuildContext context);
}

// User's code that breaks:
class MyWidget implements Widget {
  @override
  Widget build(BuildContext context) => Container();
}

// User must change to:
class MyWidget extends Widget {
  @override
  Widget build(BuildContext context) => Container();
}

// Before: unrestricted
abstract class Comparator<T> {
  int compare(T a, T b);
}

// After: interface — prevents extends, requires implements
interface class Comparator<T> {
  int compare(T a, T b);
}

// User's code that breaks:
class MyComparator extends Comparator<int> {
  @override
  int compare(int a, int b) => a - b;
}

// User must change to:
class MyComparator implements Comparator<int> {
  @override
  int compare(int a, int b) => a - b;
}

// Before: unrestricted
class Configuration {
  final String host;
  final int port;
  Configuration(this.host, this.port);
}

// After: final — prevents all subtyping
final class Configuration {
  final String host;
  final int port;
  Configuration(this.host, this.port);
}

// WRONG — using base for a pure contract
base class HashCode {
  int get hashCode;
}
// External code must extend, but there is nothing to inherit

// RIGHT — use interface for pure contracts
interface class HashCode {
  int get hashCode;
}

final class Parent {}

class Child extends Parent {
  // Same library — OK
}

// External library:
class GrandChild extends Child {} // OK — Child is not final

final class Parent {}
final class Child extends Parent {}

// COMPILE ERROR — sealed is already maximally restrictive
sealed base class Node {}
sealed interface class Node {}
sealed final class Node {}

mixin class WithState {
  final int value;
  WithState(this.value); // Parameterized constructor
}

// This works:
class Child extends WithState {
  Child(int value) : super(value);
}

// This DOES NOT work:
class Other extends Object with WithState {} // ERROR
// WithState has a parameterized constructor — cannot be used as mixin

// Abstract classes can have modifiers
abstract base class Service {
  void start();
  void stop();
}

// External code must extend (not implement)
class MyService extends Service {
  @override
  void start() { /* ... */ }
  @override
  void stop() { /* ... */ }
}

// External code CANNOT do this:
class MyService implements Service {} // COMPILE ERROR

interface class Builder {
  Builder();
  void build();
}

// External code implementing Builder must provide its own constructor
class MyBuilder implements Builder {
  MyBuilder(); // Required — does not inherit Builder()
  @override
  void build() { /* ... */ }
}

base class Animal {
  void speak() => print('...');
}

// External library — OK
class Dog extends Animal {
  @override
  void speak() => print('Woof');
}

abstract sealed class Node {} // Redundant — sealed is already abstract
abstract base class Service {} // Abstract AND base
abstract interface class Handler {} // Abstract AND interface
abstract final class Config {} // Abstract AND final — cannot be instantiated or subclassed externally

// Enums are already sealed
enum Status { active, inactive }

// This is redundant and not allowed:
// sealed enum Status { active, inactive } // May be allowed but is redundant
// base enum Status { active, inactive } // Not valid

final class ApiClient {
  // ...
}

// Same library — extending final is ALLOWED
class TestApiClient extends ApiClient {
  // For testing purposes within the same library
}