### Install Project Dependencies with Yarn

Source: https://github.com/mnasyrov/nrgy/blob/0.x/website/README.md

Installs all necessary project dependencies using the Yarn package manager. This is typically the first step before running any other commands.

```shell
$ yarn
```

--------------------------------

### Start Local Development Server with Yarn

Source: https://github.com/mnasyrov/nrgy/blob/0.x/website/README.md

Starts a local development server for the website. This command opens a browser window and reflects most changes live without requiring a server restart.

```shell
$ yarn start
```

--------------------------------

### Reactive State and Effects with Nrgy

Source: https://github.com/mnasyrov/nrgy/blob/0.x/website/src/pages/_usage-example.mdx

Demonstrates the core reactive state and effect primitives in Nrgy. It shows how to create atoms, compute derived values, and trigger side effects based on state changes. Dependencies include the 'nrgy' library.

```typescript
import { atom, compute, effect, signal } from 'nrgy';

const name = atom<string>('World');
const greetings = compute(() => `Hello ${name()}!`);

console.log(greetings());
// console: Hello World!

name.update((value) => value.toUpperCase());
effect(greetings, (value) => console.log(value));
// console: Hello WORLD!

const changeName = signal<string>();
effect(changeName, (nextValue) => name.set(nextValue));

changeName('UserName');
// console: Hello UserName!
```

--------------------------------

### Declare State Updates (With Example)

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Declares a record of factories for creating state mutations, providing an example of the state structure. This overload allows for type inference of the 'Updates' based on the provided 'stateExample' and the 'updates' object. It helps in defining and type-checking state mutation functions.

```typescript
declareStateUpdates<State, Updates>(stateExample, updates: Updates): Updates;
```

--------------------------------

### Create Store with Factory

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Initializes a state store using the factory. This function allows for creating reactive stores with initial states, optional comparators for state updates, and names for identification. It returns a store object with methods for getting, setting, updating, and querying state.

```typescript
import { Observable, Subscription, Observer, Partial } from 'rxjs';

// Assuming types like TeardownLogic, Action, EffectHandler, etc. are defined as in the previous snippets

type TeardownLogic = () => void;
type Action<Event> = { get: () => Event; value$: Observable<Event> };
type EffectHandler<Event, Result> = (event: Event) => Result | Promise<Result>;
type EffectPipeline<Event, Result> = (source: Observable<Event>) => Observable<Result>;
type EffectError<Event, ErrorType> = { event: Event; error: ErrorType };
type EffectNotification<Event, Result, ErrorType> = {
  event: Event;
  result?: Result;
  error?: ErrorType;
};

interface Effect<Event, Result, ErrorType>
  extends Readonly<Readonly<Readonly<{
    done$: Observable<Readonly<{ event: Event; result: Result }>>;
    error$: Observable<EffectError<Event, ErrorType>>;
    final$: Observable<EffectNotification<Event, Result, ErrorType>>;
    pending: Readonly<{ get: () => boolean; value$: Observable<boolean> }>;
    pendingCount: Readonly<{ get: () => number; value$: Observable<number> }>;
    result$: Observable<Result>;
  }>> & {
    handle: (source: Observable<Event> | Action<Event> | Readonly<{ get: () => Event; value$: Observable<Event> }>)
      => Subscription;
  } & {
    destroy: () => void;
  }> {
  handle: (source: Observable<Event> | Action<Event> | Readonly<{ get: () => Event; value$:
    Observable<Event> }>)
    => Subscription;
  destroy: () => void;
}

interface EffectController<Event, Result, ErrorType> {
  // ... properties and methods for effect controller
}

interface Service {
  destroy?: () => void;
}

interface ControllerProps {
  // ... properties for controller props
}

interface Controller<Service> extends Service {
  destroy?: () => void;
}

interface StoreQueryFn<State> {
  (state: State): any;
}

interface Store<State>
  extends Readonly<Readonly<Readonly<{
    get: () => State;
    value$: Observable<State>;
  }>> & {
    query: StoreQueryFn<State>;
  }> & {
    id: number;
    name?: string;
    notify: () => void;
    set: (state: State) => void;
    update: StoreUpdateFunction<State>;
  } & {
    destroy: () => void;
  }
> {}

type StoreUpdateFunction<State> = (state: State) => State;

interface Factory {
  add: (teardown: TeardownLogic) => void;
  createController: <ControllerProps>(factory: () => Readonly<ControllerProps & { destroy: () => void }>)
    => Readonly<ControllerProps & { destroy: () => void }>;
  createEffect: <Event, Result, ErrorType>(
    handler: EffectHandler<Event, Result>,
    options?: Readonly<{ pipeline?: EffectPipeline<Event, Result> }>
  ) => Effect<Event, Result, ErrorType>;
  handle: <Event, Result, ErrorType>(
    source: Observable<Event> | Action<Event> | Readonly<{ get: () => Event; value$: Observable<Event> }>,
    handler: EffectHandler<Event, Result>,
    options?: Readonly<{ pipeline?: EffectPipeline<Event, Result> }>
  ) => Effect<Event, Result, ErrorType>;
  onDestroy: (teardown: () => void) => void;
  subscribe: <T>(
    source: Observable<T>
  ) => Subscription<T>(source: Observable<T>, next: (value: T) => void) => Subscription<T>(source: Observable<T>, observer: Partial<Observer<T>>)
    => Subscription;
  createStore: <State>(
    initialState: State,
    options?: Readonly<{
      comparator?: (prevState: State, nextState: State) => boolean;
      name?: string;
      onDestroy?: () => void;
    }>
  ) => Store<State>;
}

// Example usage of createStore:
// const userStore = factory.createStore({ name: 'Guest', age: 0 }, {
//   name: 'userStore',
//   comparator: (prevState, nextState) => prevState.age === nextState.age
// });

// To update the store:
// userStore.set({ name: 'Alice', age: 30 });
// userStore.update(state => ({ ...state, age: state.age + 1 }));

// To get the current state:
// const currentState = userStore.get();

// To subscribe to state changes:
// userStore.value$.subscribe(state => console.log('User state changed:', state));

```

--------------------------------

### MVVM Pattern: Counter View Model Implementation

Source: https://github.com/mnasyrov/nrgy/blob/0.x/website/src/pages/_usage-example.mdx

Implements the Counter ViewModel using Nrgy's `declareViewModel` function. It sets up the internal state, effects, and methods for the counter. Dependencies include 'nrgy/mvc' and the defined types.

```typescript
import { declareViewModel } from 'nrgy/mvc';

import { CounterViewModelType } from './types.ts';

export const CounterViewModel = declareViewModel<CounterViewModelType>(
  ({ scope, view }) => {
    const { initialValue } = view.props;

    const counter = scope.atom(initialValue());

    scope.effect(counter, (value) => {
      // Performing a side effect
      console.log('counter', value);
    });

    return {
      state: { counter: counter.asReadonly() },

      increase: () => counter.update((prev) => prev + 1),
    };
  },
);
```

--------------------------------

### MVVM Pattern: Counter View Model Definition

Source: https://github.com/mnasyrov/nrgy/blob/0.x/website/src/pages/_usage-example.mdx

Defines the TypeScript types for a Counter ViewModel using Nrgy's MVVM utilities. It specifies the props, state, and methods available in the ViewModel. Dependencies include 'nrgy'.

```typescript
import { Atom } from 'nrgy';
import { ViewModel } from 'nrgy/mvc';

export type CounterViewModelType = ViewModel<{
  props: { initialValue: Atom<number> };

  state: { counter: Atom<number> };

  increase(): void;
}>;
```

--------------------------------

### Create Store with Initial State in TypeScript

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

The `createStore` function initializes a reactive store with a given initial state. It provides methods to get the current state, subscribe to state changes via an observable, update the state directly, or update it using a function. Optional configuration includes a comparator for state changes and a name for debugging.

```typescript
createStore<State>(initialState: State, options?: Readonly<{ comparator?: (prevState: State, nextState: State) => boolean; name?: string; onDestroy?: () => void }>)
  => Readonly<Readonly<Readonly<{ get: () => State; value$: Observable<State> }> & { query: StoreQueryFn<State> }> & { id: number; name?: string; notify: () => void; set: (state: State) => void; update: StoreUpdateFunction<State> } & { destroy: () => void }>;

```

--------------------------------

### Declare View Models for MVVM in TypeScript

Source: https://context7.com/mnasyrov/nrgy/llms.txt

Illustrates the use of `declareViewModel` for creating view models in the presentation layer, supporting props binding and state management within the MVVM pattern. It defines props, state, and actions for a counter example. Dependencies include 'nrgy/mvc'.

```typescript
import { declareViewModel, Atom, compute } from 'nrgy/mvc';

// Define view model with props and state
type CounterViewModel = {
  props: {
    initialCount: Atom<number>;
    step: Atom<number>;
  };
  state: {
    count: Atom<number>;
    doubled: Atom<number>;
  };
  increment: () => void;
  decrement: () => void;
  reset: () => void;
};

const CounterViewModel = declareViewModel<CounterViewModel>(({ scope, view }) => {
  // Get initial values from props
  const count = scope.atom(view.props.initialCount());
  const doubled = compute(() => count() * 2);

  // Actions
  const increment = () => count.update((c) => c + view.props.step());
  const decrement = () => count.update((c) => c - view.props.step());
  const reset = () => count.set(view.props.initialCount());

  // React to prop changes
  scope.effect(view.props.initialCount, (newInitial) => {
    console.log('Initial count changed to:', newInitial);
  });

  return {
    state: { count, doubled },
    increment,
    decrement,
    reset,
  };
});

```

--------------------------------

### Create Derived Reactive Values with compute() in TypeScript

Source: https://context7.com/mnasyrov/nrgy/llms.txt

Illustrates the creation of computed atoms using the `compute()` function, which derive their values from other atoms. It shows how computed values are lazily evaluated, cached, and automatically updated when their dependencies change. Examples include combining strings, depending on other computed values, handling multiple dependencies, and using custom equality functions for computed results.

```typescript
import { atom, compute, effect } from 'nrgy';

// Create source atoms
const firstName = atom('John');
const lastName = atom('Doe');

// Create computed atom
const fullName = compute(() => `${firstName()} ${lastName()}`);

console.log(fullName()); // Output: John Doe

// Updates automatically when dependencies change
firstName.set('Jane');
console.log(fullName()); // Output: Jane Doe

// Computed values can depend on other computed values
const greeting = compute(() => `Hello, ${fullName()}!`);
console.log(greeting()); // Output: Hello, Jane Doe!

// Multiple dependencies
const items = atom([1, 2, 3, 4, 5]);
const filter = atom((x: number) => x > 2);
const filteredItems = compute(() => items().filter(filter()));
console.log(filteredItems()); // Output: [3, 4, 5]

// Computed atoms with custom equality
const position = atom({ x: 0, y: 0 });
const distance = compute(
  () => Math.sqrt(position().x ** 2 + position().y ** 2),
  { equal: (a, b) => Math.abs(a - b) < 0.001 }
);

// Effects on computed values
effect(distance, (d) => console.log('Distance:', d));

position.set({ x: 3, y: 4 });
// Output: Distance: 5
```

--------------------------------

### createStore

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Creates a store for managing application state.

```APIDOC
## POST /api/stores

### Description
Creates a `Store` for managing application state. Stores provide a mechanism for holding and updating state in a predictable and reactive manner, often used in conjunction with RxJS observables.

### Method
POST

### Endpoint
/api/stores

### Parameters
#### Request Body
- **initialState** (State) - Required - The initial state of the store.
- **options** (Readonly<{ comparator?: (prevState: State, nextState: State) => boolean; name?: string; onDestroy?: () => void }>)- Optional - Configuration options for the store, including a custom comparator, name, and an optional destroy callback.

### Request Example
```json
{
  "initialState": {
    "count": 0
  },
  "options": {
    "name": "counterStore",
    "comparator": "(prevState, nextState) => prevState.count === nextState.count"
  }
}
```

### Response
#### Success Response (200)
- **store** (Readonly<Readonly<Readonly<{ get: () => State; value$: Observable<State> }> & { query: StoreQueryFn<State> }> & { id: number; name?: string; notify: () => void; set: (state: State) => void; update: StoreUpdateFunction<State> }> & { destroy: () => void }>)- The created store object.

#### Response Example
```json
{
  "store": {
    "id": 1,
    "name": "counterStore",
    "get": "() => State",
    "value$": "Observable<State>",
    "query": "StoreQueryFn<State>",
    "notify": "() => void",
    "set": "(state: State) => void",
    "update": "StoreUpdateFunction<State>",
    "destroy": "() => void"
  }
}
```
```

--------------------------------

### Query Type

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Represents a queryable state provider, offering a way to get the current value and subscribe to its changes.

```APIDOC
## Type: Query<T>

### Description
A reactive query that provides access to a state value and allows subscription to its updates.

### Type Parameters
- **T**: The type of the value managed by the query.

### Fields
- **get** (`() => T`) - A function to synchronously retrieve the current value.
- **value$** (`Observable<T>`) - An observable that emits the value whenever it changes.

### Defined in
`packages/rx-effects/src/query.ts:6`
```

--------------------------------

### Store Creation and Updates

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

This section details the creation of a store with initial state and provides mechanisms for updating that state using defined update functions.

```APIDOC
## POST /store

### Description
Creates a new store with an initial state and a set of update functions. The store provides methods to get the current state, subscribe to state changes, and update the state.

### Method
POST

### Endpoint
/store

### Parameters
#### Query Parameters
- **initialState** (State) - Required - The initial state of the store.

#### Request Body
- **updates** (Updates) - Required - An object containing functions that define how the state can be mutated. Each function should return a `StateMutation`.

### Request Example
```json
{
  "updates": {
    "increment": "(state) => state + 1",
    "decrement": "(state) => state - 1"
  }
}
```

### Response
#### Success Response (200)
- **store** (StoreWithUpdates<State, Updates>) - An object representing the created store, including methods for state management.

#### Response Example
```json
{
  "store": {
    "id": 1,
    "name": "MyStore",
    "get": "() => State",
    "value$": "Observable<State>",
    "query": "StoreQueryFn<State>",
    "notify": "() => void",
    "set": "(state: State) => void",
    "update": "(updater: StoreUpdateFunction<State>) => void",
    "destroy": "() => void"
  }
}
```

#### Defined in
[packages/rx-effects/src/store.ts:347](https://github.com/mnasyrov/rx-effects/blob/1454a59/packages/rx-effects/src/store.ts#L347)
```

--------------------------------

### Declare State Updates API

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Declares factories for creating state mutations. This API provides two overloaded methods for declaring state updates, one requiring an example state and the other inferring it.

```APIDOC
## POST /declareStateUpdates

### Description
Declares a record of factories for creating state mutations. This function helps in organizing and type-safely defining how the application state can be updated.

### Method
POST

### Endpoint
/declareStateUpdates

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
**Overload 1:** `declareStateUpdates<State>()`
- **updates** (Updates) - Required - A record of factories for state mutations.

**Overload 2:** `declareStateUpdates<State, Updates>(stateExample, updates)`
- **stateExample** (State) - Required - An example of the state structure.
- **updates** (Updates) - Required - A record of factories for state mutations.

### Request Example
**Overload 1:**
```json
{
  "updates": {
    "increment": (count) => count + 1,
    "decrement": (count) => count - 1
  }
}
```

**Overload 2:**
```json
{
  "stateExample": {
    "count": 0
  },
  "updates": {
    "increment": (count) => count + 1,
    "decrement": (count) => count - 1
  }
}
```

### Response
#### Success Response (200)
- **Updates** (Updates) - The record of state update factories.

#### Response Example
```json
{
  "message": "State updates declared successfully"
}
```
```

--------------------------------

### pipeStore

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Creates a deferred or transformed view of a store.

```APIDOC
## pipeStore

### Description
Creates a deferred or transformed view of the store.

### Method
N/A (Function Signature)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
N/A

#### Response Example
N/A

### Type Parameters
- `T`: The type of the store's state.

### Parameters
- `store` (`Readonly<...>`): The store to pipe.
- `operator` (`MonoTypeOperatorFunction<T>`): The operator to apply to the store's observable.
```

--------------------------------

### Controller Type Definition

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

The Controller type in rx-effects represents a controller for managing effects and business logic. It extends the ControllerProps and must include a 'destroy' method for cleaning up subscriptions and resources. An example demonstrates how to define a LoggerController.

```typescript
Ƭ **Controller**<`ControllerProps`>: `Readonly`<`ControllerProps` & { `destroy`: () => `void` }>

Effects and business logic controller.

Implementation of the controller must provide `destroy()` method. It should
be used for closing subscriptions and disposing resources.

**`Example`**

```ts
type LoggerController = Controller<{
  log: (message: string) => void;
}>;
```
```

--------------------------------

### Deploy Website using Yarn (SSH)

Source: https://github.com/mnasyrov/nrgy/blob/0.x/website/README.md

Deploys the website using SSH. This command builds the static content and pushes it to the 'gh-pages' branch, suitable for GitHub Pages hosting.

```shell
$ USE_SSH=true yarn deploy
```

--------------------------------

### Create and Declare Stores for State Management in TypeScript

Source: https://context7.com/mnasyrov/nrgy/llms.txt

Demonstrates how to create and declare stores using `createStore` and `declareStore` for structured state management in TypeScript. It covers defining state types, update functions, and subscribing to state changes. Dependencies include 'nrgy'.

```typescript
import { createStore, declareStore, effect } from 'nrgy';

// Define state type
type TodoState = {
  items: Array<{ id: number; text: string; done: boolean }>;
  filter: 'all' | 'active' | 'completed';
};

// Using declareStore for reusable store factory
const TodoStore = declareStore({
  initialState: {
    items: [],
    filter: 'all',
  } as TodoState,
  updates: {
    addTodo: (text: string) => (state) => ({
      ...state,
      items: [...state.items, { id: Date.now(), text, done: false }],
    }),

    toggleTodo: (id: number) => (state) => ({
      ...state,
      items: state.items.map((item) =>
        item.id === id ? { ...item, done: !item.done } : item
      ),
    }),

    removeTodo: (id: number) => (state) => ({
      ...state,
      items: state.items.filter((item) => item.id !== id),
    }),

    setFilter: (filter: TodoState['filter']) => (state) => ({
      ...state,
      filter,
    }),
  },
});

// Create store instance
const store = TodoStore();

// Subscribe to state changes
effect(store, (state) => {
  console.log('Todos:', state.items.length, 'Filter:', state.filter);
});
// Output: Todos: 0 Filter: all

// Use typed update functions
store.updates.addTodo('Learn Nrgy');
// Output: Todos: 1 Filter: all

store.updates.addTodo('Build app');
// Output: Todos: 2 Filter: all

store.updates.setFilter('active');
// Output: Todos: 2 Filter: active

// Direct state access
console.log(store().items[0].text); // Output: Learn Nrgy

// Create store with custom initial state
const customStore = TodoStore({
  items: [{ id: 1, text: 'Preset task', done: false }],
  filter: 'all'
});

// Cleanup
store.destroy();

```

--------------------------------

### Deploy Website using Yarn (No SSH)

Source: https://github.com/mnasyrov/nrgy/blob/0.x/website/README.md

Deploys the website without using SSH. Requires specifying the GitHub username for deployment, typically used for GitHub Pages hosting.

```shell
$ GIT_USER=<Your GitHub username> yarn deploy
```

--------------------------------

### createController API

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Documentation for the `createController` function, used to create a controller for managing services.

```APIDOC
## createController API

### Description

The `createController` function is a generic function used to create a `Controller` instance. It takes a `factory` function as an argument, which is responsible for creating the service instance that the controller will manage.

### Method

(Implicitly a function call, not a standard HTTP method)

### Endpoint

(Not applicable, this is a library function)

### Parameters

#### Path Parameters

(Not applicable)

#### Query Parameters

(Not applicable)

#### Request Body

(Not applicable)

### Request Example

```typescript
import { createController } from '@rx-effects/controller';

interface MyService {
  // ... service methods
}

const controller = createController<MyService>(() => {
  // factory function to create MyService instance
  return { /* ... */ };
});
```

### Response

#### Success Response (200)

- **Controller** (`Controller<Service>`): Returns a controller instance that manages the provided service.

#### Response Example

(Not applicable, this is a type definition)

### Type Parameters

- **Service**: A type that extends `AnyObject`, representing the type of the service managed by the controller.
```

--------------------------------

### Map Query Values in TypeScript

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

The `mapQuery` function transforms the value of an existing query by applying a mapping function. It takes a source query (an object with `get` and `value$` properties) and a mapper function, returning a new query with the transformed values.

```typescript
mapQuery<T, R>(query: Readonly<{ get: () => T; value$: Observable<T> }>, mapper: (value: T) => R): Query<R>;

```

--------------------------------

### Manage Subscriptions and Resources with Scopes

Source: https://github.com/mnasyrov/nrgy/wiki/Getting-Started

Shows how to use `scope` to manage subscriptions and resources, allowing for their cleanup when no longer needed. Includes adding destroyable resources and callbacks for scope destruction.

```typescript
import { scope } from 'nrgy';
import { Subject } from 'rxjs';

// Create the scope
const scope = createScope();

// Use built-in helpers for core components
const counter = scope.atom<number>(1);
const onValue = scope.signal<number>();
scope.effect(counter, onValue);
scope.effect(onValue, (value) => console.log(value));

// Register some destroyable resource
const someRxObservable = new Subject();
scope.add(
  someRxObservable.subscribe(() => {
    console.log();
  }),
);

// Register a callback to be called on scope destruction
scope.onDestroy(() => console.log('The scope is destroyed'));

// Destroy the scope
scope.destroy();
```

--------------------------------

### MVVM Pattern: Counter Higher-Order Component

Source: https://github.com/mnasyrov/nrgy/blob/0.x/website/src/pages/_usage-example.mdx

A React Higher-Order Component (HOC) that combines the Counter ViewModel and Counter View. It uses Nrgy's `withViewModel` HOC to provide the ViewModel instance to the View component. Dependencies include 'nrgy/mvc-react'.

```typescript
import { withViewModel } from 'nrgy/mvc-react';

import { CounterView } from './counter.view.tsx';
import { CounterViewModel } from './counter.viewModel.tsx';

// HOC component combines the view and the view model
export const Counter = withViewModel(CounterViewModel)(CounterView);
```

--------------------------------

### withStoreUpdates

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Creates a proxy for the store with "updates" to change a state by provided mutations.

```APIDOC
## withStoreUpdates

### Description
Creates a proxy for the store with "updates" to change a state by provided mutations.

### Method
N/A (Function Signature)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
N/A

#### Response Example
N/A

### Type Parameters
- `State`: The type of the store's state.
- `Updates`: The type of the updates object.

### Parameters
- `store` (The store object)
- `updates` (The updates object.
```

--------------------------------

### Declare State Updates (No Example)

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Declares a record of factories for creating state mutations. This function is generic over the 'State' type and returns a function that accepts 'updates' of type 'StateUpdates<State>' and returns the same 'Updates'. It's used to define how the application state can be modified.

```typescript
declareStateUpdates<State>(): <Updates>(updates: Updates) => Updates;
```

--------------------------------

### MVVM Pattern: Counter View Component

Source: https://github.com/mnasyrov/nrgy/blob/0.x/website/src/pages/_usage-example.mdx

A React functional component for the Counter View. It uses Nrgy's `useAtoms` hook to subscribe to ViewModel state and renders the current count and a button to increase it. Dependencies include 'nrgy/react' and the ViewModel types.

```typescript
import { useAtoms } from 'nrgy/react';
import { FC } from 'react';

import { CounterViewModelType } from './types.ts';

export const CounterView: FC<{
  viewModel: CounterViewModelType;
  label: string;
}> = ({ viewModel, label }) => {
  const { value } = useAtoms(viewModel.state);

  return (
    <>
      <span>
        {label}: {value}
      </span>

      <button onClick={() => viewModel.increase()} />
    </>
  );
};
```

--------------------------------

### registerStoreExtension

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Registers a store extension.

```APIDOC
## registerStoreExtension

### Description
Registers a store extension.

### Method
N/A (Function Signature)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
N/A

#### Response Example
N/A

### Parameters
- `extension` (`StoreExtension<unknown>`): The store extension to register.
```

--------------------------------

### Build Static Website Content with Yarn

Source: https://github.com/mnasyrov/nrgy/blob/0.x/website/README.md

Generates the static content for the website into the 'build' directory. The generated content can then be served by any static hosting service.

```shell
$ yarn build
```

--------------------------------

### Create and Use an Action in TypeScript

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Demonstrates how to create an Action using `createAction` and how to subscribe to its emitted events. Actions are event emitters that can be used to trigger side effects or communicate events within an application.

```typescript
import { createAction } from 'rx-effects';

// Create the action
const submitForm = createAction<{ login: string; password: string }>();

// Call the action
submitForm({ login: 'foo', password: 'bar' });

// Handle action's events
submitForm.even$.subscribe((formData) => {
  // Process the formData
  console.log('Form submitted with:', formData);
});
```

--------------------------------

### Declare a Store with Updates in TypeScript

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Demonstrates how to declare a store with an initial state and a set of update functions using `declareStore`. This function allows defining the shape of the state and the operations that can modify it. It returns a factory function to create store instances.

```typescript
type State = {
 id: string;
 name: string;
 isAdmin: boolean;
};
const initialState: State = {
 id: '',
 name: '',
 isAdmin: false
};
const createUserStore = declareStore({
 initialState,
 updates: {
   setId: (id: string) => (state) => {
     return {
       ...state,
       id: id,
     };
   },
   setName: (name: string) => (state) => {
     return {
       ...state,
       name: name,
     };
   },
   update: (id: string name: string) => (state) => {
     return {
       ...state,
       id: id,
       name: name,
     };
   },
   setIsAdmin: () => (state) => {
     return {
       ...state,
       isAdmin: true,
     };
   },
 },
});

const userStore1 = createUserStore({ id: '1', name: 'User 1', isAdmin: false });

const userStore2 = createUserStore({ id: '2', name: 'User 2', isAdmin: true });

// OR

const users = [
 createUserStore({id: 1, name: 'User 1'}),
 createUserStore({id: 2, name: 'User 2'})
]

userStore1.updates.setName('User from store 1');

assets.isEqual(userStore1.get().name, 'User from store 1');

assets.isEqual(userStore2.get().name, 'User 2');

// type of createUserStore
type UserStore = ReturnType<typeof createUserStore>;

```

--------------------------------

### Compute Function in rx-effects

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

The 'compute' function in rx-effects returns the current value of a query and registers it as a dependency for computation. It takes a query object and an optional selector function. The query object must have 'get' and 'value$' properties. The function is generic over T (query value type) and R (return type).

```typescript
▸ <`T`, `R`>(`query`, `selector`): `R`

This function returns a current value of a provided Query and registers it as a dependency for computation.
```

--------------------------------

### DeclaredStoreFactory Type Definition

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

The DeclaredStoreFactory is a type used for creating stores with state and update functionalities. It is generic over State and Updates types. The factory function accepts optional initialState and options, and returns a complex Readonly object representing the store with methods for getting, setting, updating state, and managing subscriptions.

```typescript
Ƭ **DeclaredStoreFactory**<`State`, `Updates`>: `Object`

#### Type parameters

| Name      | Type                                                       |
| :-------- | :--------------------------------------------------------- |
| `State`   | `State`                                                    |
| `Updates` | extends [`StateUpdates`](README.md#stateupdates)<`State`> |

#### Call signature

▸ (`initialState?`, `options?`): `Readonly`<`Readonly`<`Readonly`<`Readonly`<{ `get`: () => `T` ; `value$`: `Observable`<`T`> }> & { `query`: `StoreQueryFn`<`State`> }> & { `id`: `number` ; `name?`: `string` ; `notify`: () => `void` ; `set`: (`state`: `State`) => `void` ; `update`: [`StoreUpdateFunction`](README.md#storeupdatefunction)<`State`> } & { `destroy`: () => `void` }> & { `updates`: [`StoreUpdates`](README.md#storeupdates)<`State`, `Updates`> }>

##### Parameters

| Name            | Type                                                                                                                                       |
| :-------------- | :----------------------------------------------------------------------------------------------------------------------------------------- |
| `initialState?` | `FactoryStateArg`<`State`>                                                                                                                |
| `options?`      | `Readonly`<{ `comparator?`: (`prevState`: `State`, `nextState`: `State`) => `boolean` ; `name?`: `string` ; `onDestroy?`: () => `void` }> |

##### Returns

`Readonly`<`Readonly`<`Readonly`<`Readonly`<{ `get`: () => `T` ; `value$`: `Observable`<`T`> }> & { `query`: `StoreQueryFn`<`State`> }> & { `id`: `number` ; `name?`: `string` ; `notify`: () => `void` ; `set`: (`state`: `State`) => `void` ; `update`: [`StoreUpdateFunction`](README.md#storeupdatefunction)<`State`> } & { `destroy`: () => `void` }> & { `updates`: [`StoreUpdates`](README.md#storeupdates)<`State`, `Updates`> }>
```

--------------------------------

### declareViewController API

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Declares a factory for creating view controllers.

```APIDOC
## declareViewController

### Description
Declares a factory for creating view controllers.

### Method
`declareViewController<Service, Params>(factory)`

### Endpoint
N/A (This is a function declaration, not an HTTP endpoint)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
`factory`: A factory function that creates the `Service` and `Params` for the view controller.

`Service`: The type of the service used by the view controller.
`Params`: The type of the parameters for the view controller.

### Request Example
```typescript
// Example usage (assuming Service and Params types are defined elsewhere)
// const myViewControllerFactory = declareViewController<MyService, MyParams>(myFactoryFunction);
```

### Response
#### Success Response (200)
Returns a `ViewControllerFactory`.

#### Response Example
```typescript
// Type of the returned factory
type ViewControllerFactory<Service, Params> = /* ... definition ... */;
```
```

--------------------------------

### declareStore API

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Declares the base interface for creating a store with initial state and update functions.

```APIDOC
## declareStore

### Description
Declares the base interface for create store.

### Method
`declareStore<State, Updates>(declaration)`

### Endpoint
N/A (This is a function declaration, not an HTTP endpoint)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
`declaration`: `Readonly`{
  `initialState`: `State`;
  `options?`: `Readonly`{
    `comparator?`: (`prevState`: `State`, `nextState`: `State`) => `boolean`;
    `name?`: `string`;
    `onDestroy?`: () => `void`;
  };
  `updates`: `Updates`;
}

`State`: The type of the store's state.
`Updates`: An object where keys are update function names and values are functions that return a `StateMutation`.

### Request Example
```typescript
type State = {
  id: string;
  name: string;
  isAdmin: boolean;
};

const initialState: State = {
  id: '',
  name: '',
  isAdmin: false,
};

const createUserStore = declareStore({
  initialState,
  updates: {
    setId: (id: string) => (state) => {
      return {
        ...state,
        id: id,
      };
    },
    setName: (name: string) => (state) => {
      return {
        ...state,
        name: name,
      };
    },
    update: (id: string, name: string) => (state) => {
      return {
        ...state,
        id: id,
        name: name,
      };
    },
    setIsAdmin: () => (state) => {
      return {
        ...state,
        isAdmin: true,
      };
    },
  },
});

const userStore1 = createUserStore({ id: '1', name: 'User 1', isAdmin: false });
const userStore2 = createUserStore({ id: '2', name: 'User 2', isAdmin: true });

userStore1.updates.setName('User from store 1');
```

### Response
#### Success Response (200)
Returns a `DeclaredStoreFactory` which is a function that creates store instances.

#### Response Example
```typescript
// Type of createUserStore
type UserStore = ReturnType<typeof createUserStore>;
```

#### Defined in
`packages/rx-effects/src/declareStore.ts:99`
```

--------------------------------

### Create and Manage Atoms in TypeScript

Source: https://github.com/mnasyrov/nrgy/blob/0.x/website/docs/getting-started/1_atom.md

Demonstrates the creation of an atom to hold state, how to retrieve its current value, set a new value, and update the value based on its previous state using the Nrgy library.

```typescript
import { atom } from 'nrgy';

// Create Atom
const counter = atom<number>(1);

// Getting a value
console.log(counter()); // 1

// Set a new value
counter.set(2);
console.log(counter()); // 2

// Update the current value
counter.update((prev) => prev + 1);
console.log(counter()); // 3
```

--------------------------------

### Controller Creation API

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Provides functions for creating and managing controllers, including their lifecycle and effects.

```APIDOC
## POST /declareViewController

### Description
This endpoint is related to the declaration and creation of view controllers within the Rx Effects framework. It allows for the factory-based creation of controllers with specific properties and lifecycle management.

### Method
POST

### Endpoint
/declareViewController

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **factory** (function) - Required - A factory function that returns a `Readonly<ControllerProps & { destroy: () => void }>`. This factory is used to instantiate the controller.

### Request Example
```json
{
  "factory": "() => ({ ...controllerProps, destroy: () => {} })"
}
```

### Response
#### Success Response (200)
- **ViewControllerFactory** (function) - A factory function that creates a `Service` instance with provided `Params`.

#### Response Example
```json
{
  "example": "(params: Params) => Service"
}
```
```

--------------------------------

### Nrgy Factory and Scope Initialization

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Demonstrates the initialization of the Nrgy factory and the scope object. The scope provides methods for managing teardown logic, creating controllers, effects, and stores. It's the central point for managing application lifecycle and state.

```typescript
const factory = (deps: Dependencies, scope: Readonly<{
  add: (teardown: TeardownLogic) => void;
  createController: <ControllerProps>(factory: () => Readonly<ControllerProps & { destroy: () => void }>)
    => Readonly<ControllerProps & { destroy: () => void }>;
  createEffect: <Event, Result, ErrorType>(
    handler: EffectHandler<Event, Result>,
    options?: Readonly<{ pipeline?: EffectPipeline<Event, Result> }>
  ) => Readonly<Readonly<{
    done$: Observable<Readonly<{ event: Event; result: Result }>>;
    error$: Observable<EffectError<Event, ErrorType>>;
    final$: Observable<EffectNotification<Event, Result, ErrorType>>;
    pending: Readonly<{ get: () => boolean; value$: Observable<boolean> }>;
    pendingCount: Readonly<{ get: () => number; value$: Observable<number> }>;
    result$: Observable<Result>;
  }>> & {
    handle: (source: Observable<Event> | Action<Event> | Readonly<{ get: () => Event; value$: Observable<Event> }>)
      => Subscription;
  } & { destroy: () => void }>
  ) & {
    handle: <Event, Result, ErrorType>(
      source: Observable<Event> | Action<Event> | Readonly<{ get: () => Event; value$: Observable<Event> }>,
      handler: EffectHandler<Event, Result>,
      options?: Readonly<{ pipeline?: EffectPipeline<Event, Result> }>
    ) => Readonly<Readonly<{
      done$: Observable<Readonly<{ event: Event; result: Result }>>;
      error$: Observable<EffectError<Event, ErrorType>>;
      final$: Observable<EffectNotification<Event, Result, ErrorType>>;
      pending: Readonly<{ get: () => boolean; value$: Observable<boolean> }>;
      pendingCount: Readonly<{ get: () => number; value$: Observable<number> }>;
      result$: Observable<Result>;
    }>> & {
      handle: (source: Observable<Event> | Action<Event> | Readonly<{ get: () => Event; value$: Observable<Event> }>)
        => Subscription;
    } & { destroy: () => void }>
    );
  };
  onDestroy: (teardown: () => void) => void;
  subscribe: <T>(
    source: Observable<T>
  ) => Subscription<T>(
    source: Observable<T>,
    next: (value: T) => void
  ) => Subscription<T>(
    source: Observable<T>,
    observer: Partial<Observer<T>>
  ) => Subscription;
  createStore: <State>(
    initialState: State,
    options?: Readonly<{
      comparator?: (prevState: State, nextState: State) => boolean;
      name?: string;
      onDestroy?: () => void;
    }>
  ) => Readonly<Readonly<Readonly<{
    get: () => State;
    value$: Observable<State>;
  }> & { query: StoreQueryFn<State> }>
  > & {
    id: number;
    name?: string;
    notify: () => void;
    set: (state: State) => void;
    update: StoreUpdateFunction<State>;
  } & { destroy: () => void };
}>) => Service | Readonly<{
  add: (teardown: TeardownLogic) => void;
  createController: <ControllerProps>(
    factory: () => Readonly<ControllerProps & { destroy: () => void }>
  ) => Readonly<ControllerProps & { destroy: () => void }>;
  createEffect: <Event, Result, ErrorType>(
    handler: EffectHandler<Event, Result>,
    options?: Readonly<{ pipeline?: EffectPipeline<Event, Result> }>
  ) => Readonly<Readonly<{
    done$: Observable<Readonly<{ event: Event; result: Result }>>;
    error$: Observable<EffectError<Event, ErrorType>>;
    final$: Observable<EffectNotification<Event, Result, ErrorType>>;
    pending: Readonly<{ get: () => boolean; value$: Observable<boolean> }>;
    pendingCount: Readonly<{ get: () => number; value$: Observable<number> }>;
    result$: Observable<Result>;
  }>> & {
    handle: (source: Observable<Event> | Action<Event> | Readonly<{ get: () => Event; value$: Observable<Event> }>)
      => Subscription;
  } & { destroy: () => void }>
  ) & {
    handle: <Event, Result, ErrorType>(
      source: Observable<Event> | Action<Event> | Readonly<{ get: () => Event; value$: Observable<Event> }>,
      handler: EffectHandler<Event, Result>,
      options?: Readonly<{ pipeline?: EffectPipeline<Event, Result> }>
    ) => Readonly<Readonly<{
      done$: Observable<Readonly<{ event: Event; result: Result }>>;
      error$: Observable<EffectError<Event, ErrorType>>;
      final$: Observable<EffectNotification<Event, Result, ErrorType>>;
      pending: Readonly<{ get: () => boolean; value$: Observable<boolean> }>;
      pendingCount: Readonly<{ get: () => number; value$: Observable<number> }>;
      result$: Observable<Result>;
    }>> & {
      handle: (source: Observable<Event> | Action<Event> | Readonly<{ get: () => Event; value$: Observable<Event> }>)
        => Subscription;
    } & { destroy: () => void }>
    );
  };
  onDestroy: (teardown: () => void) => void;
  subscribe: <T>(
    source: Observable<T>
  ) => Subscription<T>(
    source: Observable<T>,
    next: (value: T) => void
  ) => Subscription<T>(
    source: Observable<T>,
    observer: Partial<Observer<T>>
  ) => Subscription;
  createStore: <State>(
    initialState: State,
    options?: Readonly<{
      comparator?: (prevState: State, nextState: State) => boolean;
      name?: string;
      onDestroy?: () => void;
    }>
  ) => Readonly<Readonly<Readonly<{
    get: () => State;
    value$: Observable<State>;
  }> & { query: StoreQueryFn<State> }>
  > & {
    id: number;
    name?: string;
    notify: () => void;
    set: (state: State) => void;
    update: StoreUpdateFunction<State>;
  } & { destroy: () => void };
}>);

```

--------------------------------

### Action API

Source: https://github.com/mnasyrov/nrgy/blob/0.x/docs/README.md

Documentation for the `action` function, which creates an Action type for handling events.

```APIDOC
## Action API

### Description

This API describes the `action` function, which is used to create an `Action` type that can handle events. It accepts an optional `operator` function to modify the event stream.

### Method

(Implicitly a function call, not a standard HTTP method)

### Endpoint

(Not applicable, this is a library function)

### Parameters

#### Path Parameters

(Not applicable)

#### Query Parameters

(Not applicable)

#### Request Body

(Not applicable)

### Request Example

```typescript
import { action } from '@rx-effects/action';

const myAction = action<MyEventType>();
```

### Response

#### Success Response (200)

- **Action** (`Action<Event>`): Returns an Action type that can be used to dispatch and subscribe to events.

#### Response Example

(Not applicable, this is a type definition)

### Defined in

`packages/rx-effects/src/action.ts:31`
```