import { signalTree } from 'signal-tree';

// Basic mode - smallest bundle size (~5KB)
const tree = signalTree({
  user: {
    name: 'John Doe',
    email: 'john@example.com',
  },
  settings: {
    theme: 'dark',
    notifications: true,
  },
});

// Full type-safe access to nested signals
console.log(tree.$.user.name()); // 'John Doe'
tree.$.settings.theme.set('light');

// Entity management always included (lightweight)
const users = tree.asCrud('users');
users.add({ id: 1, name: 'Alice' });

// Opt-in to advanced features as needed
const tree = signalTree(initialState, {
  enablePerformanceFeatures: true, // Master switch for advanced features
  batchUpdates: true, // Enable batching
  useMemoization: true, // Enable caching
  enableTimeTravel: true, // Enable undo/redo
  enableDevTools: true, // Connect to Redux DevTools
  trackPerformance: true, // Track metrics
});

// Now you have access to all advanced features
tree.batchUpdate((state) => ({
  /* multiple updates */
}));
tree.memoize((state) => expensiveComputation(state), 'cache-key');
tree.undo();
tree.getMetrics();

const tree = signalTree({ count: 0 });

@Component({
  template: `<button (click)="increment()">{{ tree.$.count() }}</button>`,
})
class CounterComponent {
  tree = tree;
  increment() {
    this.tree.$.count.update((n) => n + 1);
  }
}

// Actions
export const increment = createAction('[Counter] Increment');

// Reducer
export const counterReducer = createReducer(
  0,
  on(increment, (state) => state + 1)
);

// Selector
export const selectCount = (state: AppState) => state.count;

// Component
@Component({
  template: `<button (click)="increment()">{{ count$ | async }}</button>`,
})
class CounterComponent {
  count$ = this.store.select(selectCount);
  constructor(private store: Store) {}
  increment() {
    this.store.dispatch(increment());
  }
}

// Store
@Injectable()
export class CounterStore extends Store<{ count: number }> {
  constructor() {
    super({ count: 0 });
  }
}

// Query
@Injectable()
export class CounterQuery extends Query<{ count: number }> {
  count$ = this.select((state) => state.count);
  constructor(protected store: CounterStore) {
    super(store);
  }
}

// Component
@Component({
  template: `<button (click)="increment()">{{ query.count$ | async }}</button>`,
})
class CounterComponent {
  constructor(public query: CounterQuery, private store: CounterStore) {}
  increment() {
    this.store.update((state) => ({ count: state.count + 1 }));
  }
}

const counterStore = createStore({ name: 'counter' }, withProps<{ count: number }>({ count: 0 }));

@Component({
  template: `<button (click)="increment()">{{ count$ | async }}</button>`,
})
class CounterComponent {
  count$ = counterStore.pipe(select((state) => state.count));
  increment() {
    counterStore.update((state) => ({ count: state.count + 1 }));
  }
}

class CounterStore {
  @observable count = 0;
  @action increment() {
    this.count++;
  }
}

@Component({
  template: `<button (click)="store.increment()">{{ store.count }}</button>`,
})
class CounterComponent {
  store = new CounterStore();
  constructor() {
    makeObservable(this);
  }
}

// State
@State<{ count: number }>({
  name: 'counter',
  defaults: { count: 0 },
})
@Injectable()
export class CounterState {
  @Action(Increment)
  increment(ctx: StateContext<{ count: number }>) {
    ctx.patchState({ count: ctx.getState().count + 1 });
  }
}

// Action
export class Increment {
  static readonly type = '[Counter] Increment';
}

// Component
@Component({
  template: `<button (click)="increment()">{{ count$ | async }}</button>`,
})
class CounterComponent {
  @Select((state) => state.counter.count) count$: Observable<number>;
  constructor(private store: Store) {}
  increment() {
    this.store.dispatch(new Increment());
  }
}

@Component({
  template: `<button (click)="increment()">{{ count() }}</button>`,
})
class CounterComponent {
  count = signal(0);
  increment() {
    this.count.update((n) => n + 1);
  }
}

const tree = signalTree({
  users: [] as User[],
  loading: false,
  error: null as string | null,
});

const loadUsers = tree.asyncAction(async () => await api.getUsers(), {
  loadingKey: 'loading',
  errorKey: 'error',
  onSuccess: (users, tree) => tree.$.users.set(users),
});

// Component
@Component({
  template: ` @if (tree.$.loading()) { <spinner /> } @else { @for (user of tree.$.users(); track user.id) { <user-card [user]="user" /> }} `,
})
class UsersComponent {
  tree = tree;
  ngOnInit() {
    loadUsers();
  }
}

// Actions
export const loadUsers = createAction('[Users] Load');
export const loadUsersSuccess = createAction('[Users] Load Success', props<{ users: User[] }>());
export const loadUsersFailure = createAction('[Users] Load Failure', props<{ error: string }>());

// Effects
@Injectable()
export class UsersEffects {
  loadUsers$ = createEffect(() =>
    this.actions$.pipe(
      ofType(loadUsers),
      switchMap(() =>
        this.api.getUsers().pipe(
          map((users) => loadUsersSuccess({ users })),
          catchError((error) => of(loadUsersFailure({ error })))
        )
      )
    )
  );
  constructor(private actions$: Actions, private api: ApiService) {}
}

// Reducer
export const usersReducer = createReducer(
  initialState,
  on(loadUsers, (state) => ({ ...state, loading: true })),
  on(loadUsersSuccess, (state, { users }) => ({ ...state, users, loading: false, error: null })),
  on(loadUsersFailure, (state, { error }) => ({ ...state, loading: false, error }))
);

// Selectors
export const selectUsersState = createFeatureSelector<UsersState>('users');
export const selectUsers = createSelector(selectUsersState, (state) => state.users);
export const selectLoading = createSelector(selectUsersState, (state) => state.loading);

// Component
@Component({
  template: `
    <spinner *ngIf="loading$ | async"></spinner>
    <user-card *ngFor="let user of users$ | async" [user]="user"></user-card>
  `,
})
class UsersComponent {
  users$ = this.store.select(selectUsers);
  loading$ = this.store.select(selectLoading);
  constructor(private store: Store) {}
  ngOnInit() {
    this.store.dispatch(loadUsers());
  }
}

// Store
@Injectable()
export class UsersStore extends EntityStore<UsersState> {
  constructor() {
    super({ loading: false });
  }
}

// Service
@Injectable()
export class UsersService {
  constructor(private usersStore: UsersStore, private api: ApiService) {}

  loadUsers() {
    this.usersStore.setLoading(true);
    return this.api.getUsers().pipe(
      tap((users) => {
        this.usersStore.set(users);
        this.usersStore.setLoading(false);
      }),
      catchError((error) => {
        this.usersStore.setError(error);
        this.usersStore.setLoading(false);
        return of([]);
      })
    );
  }
}

// Component
@Component({
  template: `
    <spinner *ngIf="loading$ | async"></spinner>
    <user-card *ngFor="let user of users$ | async" [user]="user"></user-card>
  `,
})
class UsersComponent {
  users$ = this.query.selectAll();
  loading$ = this.query.selectLoading();
  constructor(private query: UsersQuery, private service: UsersService) {}
  ngOnInit() {
    this.service.loadUsers().subscribe();
  }
}

const usersStore = createStore(
  { name: 'users' },
  withProps<{ users: User[]; loading: boolean; error: string | null }>({
    users: [],
    loading: false,
    error: null,
  }),
  withRequestsStatus()
);

// Service
class UsersService {
  loadUsers() {
    usersStore.update(setRequestStatus('loading'));
    return this.api.getUsers().pipe(
      tap((users) => usersStore.update((state) => ({ ...state, users }), setRequestStatus('success'))),
      catchError((error) => {
        usersStore.update(setRequestStatus('error'));
        return of([]);
      })
    );
  }
}

// Component
@Component({
  template: `
    <spinner *ngIf="loading$ | async"></spinner>
    <user-card *ngFor="let user of users$ | async" [user]="user"></user-card>
  `,
})
class UsersComponent {
  users$ = usersStore.pipe(select((state) => state.users));
  loading$ = usersStore.pipe(
    selectRequestStatus(),
    map((status) => status === 'loading')
  );
  ngOnInit() {
    this.service.loadUsers().subscribe();
  }
}

class UsersStore {
  @observable users: User[] = [];
  @observable loading = false;
  @observable error: string | null = null;

  @action async loadUsers() {
    this.loading = true;
    try {
      const users = await api.getUsers();
      runInAction(() => {
        this.users = users;
        this.loading = false;
      });
    } catch (error) {
      runInAction(() => {
        this.error = error.message;
        this.loading = false;
      });
    }
  }
}

// Component
@Component({
  template: `
    <spinner *ngIf="store.loading"></spinner>
    <user-card *ngFor="let user of store.users" [user]="user"></user-card>
  `,
})
class UsersComponent {
  store = new UsersStore();
  ngOnInit() {
    this.store.loadUsers();
  }
}

// State
export interface UsersStateModel {
  users: User[];
  loading: boolean;
  error: string | null;
}

@State<UsersStateModel>({
  name: 'users',
  defaults: { users: [], loading: false, error: null },
})
@Injectable()
export class UsersState {
  @Action(LoadUsers)
  loadUsers(ctx: StateContext<UsersStateModel>) {
    ctx.patchState({ loading: true });
    return this.api.getUsers().pipe(
      tap((users) => ctx.patchState({ users, loading: false, error: null })),
      catchError((error) => {
        ctx.patchState({ loading: false, error: error.message });
        return of([]);
      })
    );
  }
}

// Action
export class LoadUsers {
  static readonly type = '[Users] Load Users';
}

// Component
@Component({
  template: `
    <spinner *ngIf="loading$ | async"></spinner>
    <user-card *ngFor="let user of users$ | async" [user]="user"></user-card>
  `,
})
class UsersComponent {
  @Select(UsersState) state$: Observable<UsersStateModel>;
  users$ = this.state$.pipe(map((state) => state.users));
  loading$ = this.state$.pipe(map((state) => state.loading));
  constructor(private store: Store) {}
  ngOnInit() {
    this.store.dispatch(new LoadUsers());
  }
}

@Component({
  template: ` @if (loading()) { <spinner /> } @else { @for (user of users(); track user.id) { <user-card [user]="user" /> }} `,
})
class UsersComponent {
  users = signal<User[]>([]);
  loading = signal(false);
  error = signal<string | null>(null);

  async ngOnInit() {
    this.loading.set(true);
    try {
      const users = await api.getUsers();
      this.users.set(users);
    } catch (error) {
      this.error.set(error.message);
    } finally {
      this.loading.set(false);
    }
  }
}

const todoTree = signalTree({ todos: [] as Todo[] });
const todos = todoTree.asCrud<Todo>('todos');

// All CRUD operations built-in
todos.add({ id: '1', text: 'Learn SignalTree', done: false });
todos.update('1', { done: true });
todos.upsert({ id: '2', text: 'Build app', done: false });
todos.remove('1');

// Reactive queries
const activeTodos = todos.findBy((todo) => !todo.done);
const todoById = todos.findById('1');
const todoCount = todos.selectTotal();

// Component
@Component({
  template: `
    <div>Total: {{ todos.selectTotal()() }}</div>
    @for (todo of todos.selectAll()(); track todo.id) {
    <todo-item [todo]="todo" (toggle)="todos.update(todo.id, { done: !todo.done })" />
    }
  `,
})
class TodosComponent {
  todos = todos;
}

// Entity adapter
export const todoAdapter = createEntityAdapter<Todo>();

// Initial state
export const initialState = todoAdapter.getInitialState();

// Actions
export const addTodo = createAction('[Todo] Add', props<{ todo: Todo }>());
export const updateTodo = createAction('[Todo] Update', props<{ id: string; changes: Partial<Todo> }>());
export const deleteTodo = createAction('[Todo] Delete', props<{ id: string }>());
export const upsertTodo = createAction('[Todo] Upsert', props<{ todo: Todo }>());

// Reducer
export const todoReducer = createReducer(
  initialState,
  on(addTodo, (state, { todo }) => todoAdapter.addOne(todo, state)),
  on(updateTodo, (state, { id, changes }) => todoAdapter.updateOne({ id, changes }, state)),
  on(deleteTodo, (state, { id }) => todoAdapter.removeOne(id, state)),
  on(upsertTodo, (state, { todo }) => todoAdapter.upsertOne(todo, state))
);

// Selectors
export const selectTodoState = createFeatureSelector<EntityState<Todo>>('todos');
export const { selectAll: selectAllTodos, selectEntities: selectTodoEntities, selectIds: selectTodoIds, selectTotal: selectTotalTodos } = todoAdapter.getSelectors(selectTodoState);

export const selectActiveTodos = createSelector(selectAllTodos, (todos) => todos.filter((todo) => !todo.done));

// Component
@Component({
  template: `
    <div>Total: {{ totalTodos$ | async }}</div>
    <todo-item *ngFor="let todo of todos$ | async" [todo]="todo" (toggle)="toggleTodo(todo)" />
  `,
})
class TodosComponent {
  todos$ = this.store.select(selectAllTodos);
  totalTodos$ = this.store.select(selectTotalTodos);

  constructor(private store: Store) {}

  addTodo(text: string) {
    this.store.dispatch(addTodo({ todo: { id: uuid(), text, done: false } }));
  }

  toggleTodo(todo: Todo) {
    this.store.dispatch(updateTodo({ id: todo.id, changes: { done: !todo.done } }));
  }
}

// Store
@Injectable()
export class TodosStore extends EntityStore<TodosState> {
  constructor() {
    super();
  }
}

// Query
@Injectable()
export class TodosQuery extends QueryEntity<TodosState> {
  selectActive$ = this.selectAll({ filterBy: (entity) => !entity.done });
  constructor(protected store: TodosStore) {
    super(store);
  }
}

// Service
@Injectable()
export class TodosService {
  constructor(private todosStore: TodosStore) {}

  add(todo: Todo) {
    this.todosStore.add(todo);
  }
  update(id: string, todo: Partial<Todo>) {
    this.todosStore.update(id, todo);
  }
  remove(id: string) {
    this.todosStore.remove(id);
  }
  upsert(todo: Todo) {
    this.todosStore.upsert(todo.id, todo);
  }
}

// Component
@Component({
  template: `
    <div>Total: {{ query.selectCount() | async }}</div>
    <todo-item *ngFor="let todo of query.selectAll() | async" [todo]="todo" (toggle)="service.update(todo.id, { done: !todo.done })" />
  `,
})
class TodosComponent {
  constructor(public query: TodosQuery, public service: TodosService) {}
}

const todosStore = createStore({ name: 'todos' }, withEntities<Todo>());

// Repository
const todosRepo = {
  todos$: todosStore.pipe(selectAllEntities()),
  activeTodos$: todosStore.pipe(
    selectAllEntities(),
    map((todos) => todos.filter((t) => !t.done))
  ),
  total$: todosStore.pipe(selectEntitiesCount()),

  add: (todo: Todo) => todosStore.update(addEntities(todo)),
  update: (id: string, changes: Partial<Todo>) => todosStore.update(updateEntities(id, changes)),
  remove: (id: string) => todosStore.update(deleteEntities(id)),
  upsert: (todo: Todo) => todosStore.update(upsertEntities(todo)),
};

// Component
@Component({
  template: `
    <div>Total: {{ todosRepo.total$ | async }}</div>
    <todo-item *ngFor="let todo of todosRepo.todos$ | async" [todo]="todo" (toggle)="todosRepo.update(todo.id, { done: !todo.done })" />
  `,
})
class TodosComponent {
  todosRepo = todosRepo;
}

class TodosStore {
  @observable todos = new Map<string, Todo>();

  @computed get allTodos() {
    return Array.from(this.todos.values());
  }
  @computed get activeTodos() {
    return this.allTodos.filter((t) => !t.done);
  }
  @computed get total() {
    return this.todos.size;
  }

  @action add(todo: Todo) {
    this.todos.set(todo.id, todo);
  }
  @action update(id: string, changes: Partial<Todo>) {
    const todo = this.todos.get(id);
    if (todo) {
      Object.assign(todo, changes);
      this.todos.set(id, { ...todo, ...changes });
    }
  }
  @action remove(id: string) {
    this.todos.delete(id);
  }
  @action upsert(todo: Todo) {
    this.todos.set(todo.id, todo);
  }

  findById(id: string) {
    return this.todos.get(id);
  }
}

// Component
@Component({
  template: `
    <div>Total: {{ store.total }}</div>
    <todo-item *ngFor="let todo of store.allTodos" [todo]="todo" (toggle)="store.update(todo.id, { done: !todo.done })" />
  `,
})
class TodosComponent {
  store = new TodosStore();
  constructor() {
    makeObservable(this);
  }
}

// State
interface TodosStateModel {
  todos: Record<string, Todo>;
}

@State<TodosStateModel>({
  name: 'todos',
  defaults: { todos: {} },
})
@Injectable()
export class TodosState {
  @Selector()
  static getAllTodos(state: TodosStateModel) {
    return Object.values(state.todos);
  }

  @Selector()
  static getActiveTodos(state: TodosStateModel) {
    return Object.values(state.todos).filter((t) => !t.done);
  }

  @Action(AddTodo)
  addTodo(ctx: StateContext<TodosStateModel>, { todo }: AddTodo) {
    ctx.patchState({
      todos: { ...ctx.getState().todos, [todo.id]: todo },
    });
  }

  @Action(UpdateTodo)
  updateTodo(ctx: StateContext<TodosStateModel>, { id, changes }: UpdateTodo) {
    const state = ctx.getState();
    const todo = state.todos[id];
    if (todo) {
      ctx.patchState({
        todos: { ...state.todos, [id]: { ...todo, ...changes } },
      });
    }
  }
}

// Actions
export class AddTodo {
  constructor(public todo: Todo) {}
}
export class UpdateTodo {
  constructor(public id: string, public changes: Partial<Todo>) {}
}

// Component
@Component({
  template: ` <todo-item *ngFor="let todo of todos$ | async" [todo]="todo" (toggle)="store.dispatch(new UpdateTodo(todo.id, {done: !todo.done}))" /> `,
})
class TodosComponent {
  @Select(TodosState.getAllTodos) todos$: Observable<Todo[]>;
  constructor(private store: Store) {}
}

@Component({
  template: `
    <div>Total: {{ todos().length }}</div>
    @for (todo of todos(); track todo.id) {
    <todo-item [todo]="todo" (toggle)="updateTodo(todo.id, { done: !todo.done })" />
    }
  `,
})
class TodosComponent {
  todos = signal<Todo[]>([]);

  activeTodos = computed(() => this.todos().filter((t) => !t.done));
  total = computed(() => this.todos().length);

  addTodo(todo: Todo) {
    this.todos.update((todos) => [...todos, todo]);
  }

  updateTodo(id: string, changes: Partial<Todo>) {
    this.todos.update((todos) => todos.map((todo) => (todo.id === id ? { ...todo, ...changes } : todo)));
  }

  removeTodo(id: string) {
    this.todos.update((todos) => todos.filter((todo) => todo.id !== id));
  }

  findById(id: string) {
    return this.todos().find((todo) => todo.id === id);
  }
}

const form = createFormTree(
  {
    email: '',
    password: '',
    confirmPassword: '',
  },
  {
    validators: {
      email: validators.email('Invalid email'),
      password: validators.minLength(8),
      confirmPassword: (value, form) => (value !== form.password ? 'Passwords must match' : null),
    },
  }
);

// Component
@Component({
  template: `
    <form (ngSubmit)="onSubmit()">
      <input [value]="form.$.email()" (input)="form.setValue('email', $event.target.value)" />
      @if (form.getFieldError('email')(); as error) { <span>{{ error }}</span> }

      <button [disabled]="!form.valid()">Submit</button>
    </form>
  `,
})
class FormComponent {
  form = form;
  async onSubmit() {
    await this.form.submit((values) => api.register(values));
  }
}

// Form state in store
interface FormState {
  values: FormValues;
  errors: Record<string, string>;
  submitting: boolean;
}

// Actions
export const updateForm = createAction('[Form] Update', props<{ field: string; value: any }>());
export const submitForm = createAction('[Form] Submit');
export const submitSuccess = createAction('[Form] Submit Success');
export const submitFailure = createAction('[Form] Submit Failure', props<{ errors: Record<string, string> }>());

// Reducer
const formReducer = createReducer(
  initialState,
  on(updateForm, (state, { field, value }) => ({
    ...state,
    values: { ...state.values, [field]: value },
  })),
  on(submitForm, (state) => ({ ...state, submitting: true })),
  on(submitSuccess, (state) => ({ ...state, submitting: false, errors: {} })),
  on(submitFailure, (state, { errors }) => ({ ...state, submitting: false, errors }))
);

// Component using Reactive Forms
@Component({
  template: `
    <form [formGroup]="form" (ngSubmit)="onSubmit()">
      <input formControlName="email" />
      <div *ngIf="form.get('email')?.errors">{{ form.get('email')?.errors?.['email'] }}</div>

      <button [disabled]="form.invalid || (submitting$ | async)">Submit</button>
    </form>
  `,
})
class FormComponent {
  form = this.fb.group(
    {
      email: ['', [Validators.required, Validators.email]],
      password: ['', [Validators.required, Validators.minLength(8)]],
      confirmPassword: ['', [Validators.required]],
    },
    { validators: this.passwordMatchValidator }
  );

  submitting$ = this.store.select((state) => state.form.submitting);

  constructor(private fb: FormBuilder, private store: Store) {}

  onSubmit() {
    if (this.form.valid) {
      this.store.dispatch(submitForm());
    }
  }

  passwordMatchValidator(form: AbstractControl) {
    const password = form.get('password');
    const confirmPassword = form.get('confirmPassword');
    return password?.value === confirmPassword?.value ? null : { mismatch: true };
  }
}

// Using Akita Forms Manager
@Injectable()
export class FormService {
  constructor(private formsManager: AkitaNgFormsManager) {}

  createForm() {
    const form = new FormGroup({
      email: new FormControl('', [Validators.required, Validators.email]),
      password: new FormControl('', [Validators.required, Validators.minLength(8)]),
      confirmPassword: new FormControl('', Validators.required),
    });

    this.formsManager.upsert('registration', form);
    return form;
  }
}

// Component
@Component({
  template: `
    <form [formGroup]="form" (ngSubmit)="onSubmit()">
      <input formControlName="email" />
      <div *ngIf="errors$ | async as errors">{{ errors.email }}</div>

      <button [disabled]="form.invalid">Submit</button>
    </form>
  `,
})
class FormComponent {
  form = this.service.createForm();
  errors$ = this.formsManager.selectErrors('registration');

  constructor(private service: FormService, private formsManager: AkitaNgFormsManager) {}

  async onSubmit() {
    if (this.form.valid) {
      await api.register(this.form.value);
    }
  }
}

// Form store
const formStore = createStore(
  { name: 'form' },
  withProps<{
    values: FormValues;
    errors: Record<string, string>;
    touched: Record<string, boolean>;
  }>({
    values: { email: '', password: '', confirmPassword: '' },
    errors: {},
    touched: {},
  })
);

// Form logic
const formLogic = {
  setValue: (field: string, value: any) => {
    formStore.update((state) => ({
      ...state,
      values: { ...state.values, [field]: value },
      touched: { ...state.touched, [field]: true },
    }));
    validateField(field, value);
  },

  validateField: (field: string, value: any) => {
    const errors = { ...formStore.getValue().errors };

    if (field === 'email' && !value.includes('@')) {
      errors.email = 'Invalid email';
    } else {
      delete errors.email;
    }

    formStore.update((state) => ({ ...state, errors }));
  },
};

// Component
@Component({
  template: `
    <form (ngSubmit)="onSubmit()">
      <input [value]="values.email" (input)="formLogic.setValue('email', $event.target.value)" />
      <div *ngIf="errors.email">{{ errors.email }}</div>

      <button [disabled]="hasErrors">Submit</button>
    </form>
  `,
})
class FormComponent {
  values$ = formStore.pipe(select((state) => state.values));
  errors$ = formStore.pipe(select((state) => state.errors));
  formLogic = formLogic;

  get hasErrors() {
    return Object.keys(formStore.getValue().errors).length > 0;
  }
}

@Component({
  template: `
    <form (ngSubmit)="onSubmit()">
      <input [value]="form.email()" (input)="updateField('email', $event.target.value)" />
      @if (errors().email) { <span>{{ errors().email }}</span> }

      <input [value]="form.password()" (input)="updateField('password', $event.target.value)" />
      @if (errors().password) { <span>{{ errors().password }}</span> }

      <button [disabled]="!isValid()">Submit</button>
    </form>
  `,
})
class FormComponent {
  form = {
    email: signal(''),
    password: signal(''),
    confirmPassword: signal(''),
  };

  errors = signal<Record<string, string>>({});
  touched = signal<Record<string, boolean>>({});

  isValid = computed(() => {
    const errorList = this.errors();
    return Object.keys(errorList).length === 0 && this.form.email().length > 0 && this.form.password().length > 0;
  });

  updateField(field: string, value: string) {
    this.form[field].set(value);
    this.touched.update((t) => ({ ...t, [field]: true }));
    this.validate(field, value);
  }

  validate(field: string, value: string) {
    const newErrors = { ...this.errors() };

    if (field === 'email' && !value.includes('@')) {
      newErrors.email = 'Invalid email';
    } else if (field === 'email') {
      delete newErrors.email;
    }

    if (field === 'password' && value.length < 8) {
      newErrors.password = 'Must be at least 8 characters';
    } else if (field === 'password') {
      delete newErrors.password;
    }

    this.errors.set(newErrors);
  }

  async onSubmit() {
    if (this.isValid()) {
      await api.register({
        email: this.form.email(),
        password: this.form.password(),
      });
    }
  }
}

// Create a basic tree (minimal bundle)
const tree = signalTree(initialState);

// Core features always included:
tree.state.property(); // Read signal value
tree.$.property(); // Shorthand for state
tree.state.property.set(value); // Update signal
tree.unwrap(); // Get plain object
tree.update(updater); // Update entire tree
tree.asCrud('entityKey'); // Entity helpers (lightweight)
tree.asyncAction(op, config); // Async actions (lightweight)

// Enable enhanced mode
const tree = signalTree(data, {
  enablePerformanceFeatures: true,  // Master switch - enables middleware system
  batchUpdates: true,               // +1KB - Enable batching
  useMemoization: true,             // +2KB - Enable caching
  enableTimeTravel: true,           // +3KB - Enable undo/redo
  enableDevTools: true,             // +1KB - DevTools integration
  trackPerformance: true            // +0.5KB - Metrics tracking
});

// Enhanced features (only available when enabled)
tree.batchUpdate(state => ({ ... }));        // Requires batchUpdates: true
tree.memoize(fn, 'cache-key');              // Requires useMemoization: true
tree.undo() / tree.redo();                  // Requires enableTimeTravel: true
tree.getMetrics();                           // Requires trackPerformance: true
tree.addTap(middleware);                    // Requires enablePerformanceFeatures: true

// Start simple (5KB)
let tree = signalTree({ count: 0 });

// Method stubs provide helpful guidance
tree.batchUpdate(() => {});
// Console: ⚠️ batchUpdate() called but batching is not enabled.
// To enable: signalTree(data, { enablePerformanceFeatures: true, batchUpdates: true })

// Upgrade when needed (15KB)
tree = signalTree(state, {
  enablePerformanceFeatures: true,
  batchUpdates: true,
  useMemoization: true,
});
// Now batchUpdate and memoize work without warnings

const entityHelpers = tree.asCrud('users');

entityHelpers.add(user);
entityHelpers.update(id, changes);
entityHelpers.remove(id);
entityHelpers.upsert(user);

const user = entityHelpers.findById(id);
const activeUsers = entityHelpers.findBy((u) => u.active);

const loadData = tree.asyncAction(async (params) => await api.getData(params), {
  loadingKey: 'loading',
  errorKey: 'error',
  onSuccess: (data, tree) => tree.$.data.set(data),
});

const tree = signalTree(data, {
  enablePerformanceFeatures: true,
  enableTimeTravel: true,
});

tree.undo();
tree.redo();
const history = tree.getHistory();
tree.resetHistory();

const shopTree = signalTree(
  {
    products: {
      items: [] as Product[],
      loading: false,
      filters: {
        category: null as string | null,
        priceRange: { min: 0, max: 1000 },
      },
    },
    cart: {
      items: [] as CartItem[],
      total: 0,
    },
    user: {
      profile: null as User | null,
      isAuthenticated: false,
    },
  },
  {
    enablePerformanceFeatures: true,
    useMemoization: true,
    enableDevTools: true,
    treeName: 'ShopState',
  }
);

// Computed values with automatic memoization
const cartTotal = shopTree.memoize((state) => {
  return state.cart.items.reduce((sum, item) => {
    const product = state.products.items.find((p) => p.id === item.productId);
    return sum + (product?.price || 0) * item.quantity;
  }, 0);
}, 'cart-total');

// Async product loading
const loadProducts = shopTree.asyncAction(async (filters) => await api.getProducts(filters), {
  loadingKey: 'products.loading',
  onSuccess: (products, tree) => tree.$.products.items.set(products),
});

import { createFormTree, validators } from 'signal-tree';

const registrationForm = createFormTree(
  {
    username: '',
    email: '',
    password: '',
    confirmPassword: '',
  },
  {
    validators: {
      username: validators.minLength(3),
      email: validators.email(),
      password: validators.pattern(/^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$/),
      confirmPassword: (value, form) => (value !== form.password ? 'Passwords must match' : null),
    },
    asyncValidators: {
      username: async (value) => {
        const exists = await api.checkUsername(value);
        return exists ? 'Username taken' : null;
      },
    },
  }
);

// Component usage
@Component({
  template: `
    <form (ngSubmit)="onSubmit()">
      <input [value]="form.$.username()" (input)="form.setValue('username', $event.target.value)" [class.error]="form.getFieldError('username')()" />
      @if (form.getFieldError('username')(); as error) {
      <span class="error">{{ error }}</span>
      }

      <button type="submit" [disabled]="!form.valid() || form.submitting()">Register</button>
    </form>
  `,
})
class RegistrationComponent {
  form = registrationForm;

  async onSubmit() {
    await this.form.submit(async (values) => {
      return await api.register(values);
    });
  }
}

// Step 1: Create parallel tree
const tree = signalTree(initialState);

// Step 2: Gradually migrate components
// Before
users$ = this.store.select(selectUsers);

// After
users = this.tree.$.users;

// Step 3: Replace effects with async actions
// Before
loadUsers$ = createEffect(() =>
  this.actions$.pipe(
    ofType(loadUsers),
    switchMap(() => this.api.getUsers())
  )
);

// After
loadUsers = tree.asyncAction(() => api.getUsers(), { onSuccess: (users, tree) => tree.$.users.set(users) });

// Before - Scattered signals
const userSignal = signal(null);
const loadingSignal = signal(false);
const errorSignal = signal(null);

// After - Organized tree
const tree = signalTree({
  user: null,
  loading: false,
  error: null,
});

// SignalTree Basic (5KB) includes:
✅ Hierarchical signals structure
✅ Type-safe updates
✅ Entity CRUD operations
✅ Async action helpers
✅ Form management basics

// Elf Comparable (6-7KB) requires:
import { createStore, withProps } from '@ngneat/elf';        // 3KB
import { withEntities } from '@ngneat/elf-entities';          // +2KB
import { withRequestsStatus } from '@ngneat/elf-requests';   // +1.5KB
// Total: ~6.5KB for similar features

// SignalTree advantage: Everything works out of the box
// Elf advantage: Can start with just 2KB if you need less

// What you ACTUALLY ship:

// SignalTree Basic (5KB) - Most apps need just this
const tree = signalTree(state);
// Includes: signals, entities, async, forms basics

// SignalTree Enhanced (15KB) - When you need everything
const tree = signalTree(state, { enablePerformanceFeatures: true, ...options });
// Adds: memoization, time-travel, devtools, batching, middleware

// Elf "Equivalent" (10KB) - To match SignalTree features
import { createStore, withProps } from '@ngneat/elf'; // 3KB
import { withEntities, selectAll } from '@ngneat/elf-entities'; // 2KB
import { withRequestsStatus } from '@ngneat/elf-requests'; // 1.5KB
import { devtools } from '@ngneat/elf-devtools'; // 3KB
// Still missing: forms, time-travel, integrated patterns

// NgRx "Basic" (50KB+) - No way to start smaller
import { Store, createAction, createReducer } from '@ngrx/store'; // 25KB
import { Actions, createEffect } from '@ngrx/effects'; // 10KB
import { EntityAdapter } from '@ngrx/entity'; // 8KB
import { StoreDevtoolsModule } from '@ngrx/store-devtools'; // 5KB
// Still missing: forms integration