Добавил метод merge

src/index.ts

@@ -1,5 +1,5 @@
-export * from "./event";
 export * from "./effect";
+export * from "./event";
+export * from "./methods";
 export * from "./store";
-export * from "./utils";
 export * from "./types.h";

src/methods.test.ts

@@ -0,0 +1,35 @@
+import { createStore } from "./store";
+import { combine, merge } from "./methods";
+import { createEvent } from "./event";
+
+describe("methods", () => {
+  it("should be create combine store", () => {
+    const $balance = createStore(0);
+    const $username = createStore("zerobias");
+    const watcherMock = jest.fn();
+
+    const $greeting = combine(
+      $balance,
+      $username,
+      (balance, username) => `Hello, ${username}. Your balance is ${balance}`,
+    );
+
+    $greeting.watch(watcherMock);
+    expect(watcherMock).toHaveBeenCalledWith("Hello, zerobias. Your balance is 0");
+  });
+
+  it("should be create new event that triggers upon any of the given units being triggered", () => {
+    const watcherMock = jest.fn();
+    const foo = createEvent<number>();
+    const bar = createEvent<number>();
+    const baz = merge(foo, bar);
+
+    baz.watch(watcherMock);
+
+    foo(10);
+    expect(watcherMock).toHaveBeenCalledWith(10);
+
+    baz(42);
+    expect(watcherMock).toHaveBeenCalledWith(42);
+  });
+});

src/methods.ts

@@ -0,0 +1,33 @@
+import { createEvent, type Event } from "./event";
+import { createStore, type Store } from "./store";
+import type { Unit } from "./types.h";
+
+type States<S extends Store<unknown>[]> = {
+  [Key in keyof S]: S[Key] extends Store<infer U> ? U : never;
+};
+
+type CombineFn<S extends Store<unknown>[], NewStore> = (...states: States<S>) => NewStore;
+
+export function combine<S extends Store<unknown>[], NewStore>(
+  ...args: [...S, CombineFn<S, NewStore>]
+): Store<NewStore> {
+  const stores = args.slice(0, -1) as S;
+  const fn = args[args.length - 1] as CombineFn<S, NewStore>;
+
+  const getStoreState = () => fn(...(stores.map((store) => store.getState()) as States<S>));
+
+  const updateStore = createEvent();
+  const newStore = createStore<NewStore>(getStoreState()).on(updateStore, () => getStoreState());
+
+  stores.forEach((store) => store.watch(() => updateStore()));
+
+  return newStore;
+}
+
+export function merge<T>(...units: Unit<T>[]): Event<T> {
+  const event = createEvent<T>();
+
+  units.forEach((unit) => unit.watch(event));
+
+  return event;
+}

src/store.ts

@@ -1,8 +1,5 @@
-import type { Effect } from "./effect";
-import { createEvent, type Event } from "./event";
-import type { Unsubscribe } from "./types.h";
-
-type Unit<T> = Effect<T, unknown> | Event<T> | Store<T>;
+import { createEvent } from "./event";
+import type { Unit, Unsubscribe } from "./types.h";
 
 export interface Store<State> {
   map<NewState>(fn: (state: State, lastState?: NewState) => NewState): Store<NewState>;
@@ -25,7 +22,7 @@ export interface Store<State> {
 
 export function createStore<State>(defaultState: State): Store<State> {
   const watchers: Set<(state: State) => void> = new Set();
-  const subscribers: Map<Unit<unknown>, () => void> = new Map();
+  const subscribers: Map<Unit<unknown>, Unsubscribe> = new Map();
   const initialState = { ...{ defaultState } };
 
   let state = defaultState;
@@ -54,10 +51,10 @@ export function createStore<State>(defaultState: State): Store<State> {
       return $store;
     },
     off<Payload>(trigger: Unit<Payload>): void {
-      const subscriber = subscribers.get(trigger as Unit<unknown>);
+      const unsubscribe = subscribers.get(trigger as Unit<unknown>);
 
-      if (subscriber) {
-        subscriber();
+      if (unsubscribe) {
+        unsubscribe();
         subscribers.delete(trigger as Unit<unknown>);
       }
     },

src/types.h.ts

@@ -1 +1,7 @@
+import type { Effect } from "./effect";
+import type { Event } from "./event";
+import type { Store } from "./store";
+
 export type Unsubscribe = () => void;
+
+export type Unit<T> = Effect<T, unknown> | Event<T> | Store<T>;