@quantform/core 0.7.0-beta.4 → 0.7.0-beta.41

package/dist/replay/replay-guard.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from 'rxjs';
+import { dependency } from '../use-hash';
+export declare function replayGuard<T extends Array<dependency>, K>(fn: (...args: T) => Observable<{
+    timestamp: number;
+    payload: K;
+}>): (...args: T) => Observable<{
+    timestamp: number;
+    payload: K;
+}>;
+//# sourceMappingURL=replay-guard.d.ts.map

package/dist/replay/replay-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-guard.d.ts","sourceRoot":"","sources":["../../src/replay/replay-guard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAElC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,wBAAgB,WAAW,CAAC,CAAC,SAAS,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC,EACxD,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,CAAA;CAAE,CAAC,GAChE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,CAAA;CAAE,CAAC,CAE/D"}

package/dist/replay/replay-guard.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replayGuard = void 0;
+const use_replay_breakpoint_1 = require("./use-replay-breakpoint");
+function replayGuard(fn) {
+    return (...args) => (0, use_replay_breakpoint_1.useReplayBreakpoint)(fn(...args));
+}
+exports.replayGuard = replayGuard;

package/dist/replay/replay.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from 'rxjs';
+import { dependency } from '../use-hash';
+export declare function replay<T extends Array<dependency>, K>(fn: (...args: T) => Observable<{
+    timestamp: number;
+    payload: K;
+}>, dependencies: dependency[]): (...args: T) => Observable<{
+    timestamp: number;
+    payload: K;
+}>;
+//# sourceMappingURL=replay.d.ts.map

package/dist/replay/replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../src/replay/replay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAElC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAK3C,wBAAgB,MAAM,CAAC,CAAC,SAAS,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC,EACnD,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,CAAA;CAAE,CAAC,EACjE,YAAY,EAAE,UAAU,EAAE,GACzB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,CAAA;CAAE,CAAC,CAE/D"}

package/dist/replay/replay.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replay = void 0;
+const with_memo_1 = require("../with-memo");
+const use_replay_1 = require("./use-replay");
+function replay(fn, dependencies) {
+    return (0, with_memo_1.withMemo)((...args) => (0, use_replay_1.useReplay)(fn(...args), [...dependencies, ...args]));
+}
+exports.replay = replay;

package/dist/replay/use-replay-breakpoint.d.ts

@@ -0,0 +1,3 @@
+import { Observable } from 'rxjs';
+export declare function useReplayBreakpoint<T>(input: Observable<T>): Observable<T>;
+//# sourceMappingURL=use-replay-breakpoint.d.ts.map

package/dist/replay/use-replay-breakpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-replay-breakpoint.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-breakpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,UAAU,EAAE,MAAM,MAAM,CAAC;AAO5C,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAqB1E"}

package/dist/replay/use-replay-breakpoint.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReplayBreakpoint = void 0;
+const rxjs_1 = require("rxjs");
+const use_execution_mode_1 = require("../use-execution-mode");
+const use_logger_1 = require("../use-logger");
+const use_replay_manager_1 = require("./use-replay-manager");
+function useReplayBreakpoint(input) {
+    const { isReplay } = (0, use_execution_mode_1.useExecutionMode)();
+    if (!isReplay) {
+        return input;
+    }
+    const { info } = (0, use_logger_1.useLogger)('useReplayBreakpoint');
+    const { stop, tryContinue } = (0, use_replay_manager_1.useReplayManager)();
+    info('locking resource...');
+    stop();
+    return input.pipe((0, rxjs_1.finalize)(() => {
+        info('unlocking resource');
+        tryContinue();
+    }));
+}
+exports.useReplayBreakpoint = useReplayBreakpoint;

package/dist/replay/use-replay-manager.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+import { dependency } from '../use-hash';
+export declare const useReplayManager: () => {
+    timestamp(): number;
+    stop(): void;
+    tryContinue: () => void;
+    when<T>(dependencies: dependency[]): Observable<{
+        timestamp: number;
+        payload: T;
+    }>;
+};
+//# sourceMappingURL=use-replay-manager.d.ts.map

package/dist/replay/use-replay-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-replay-manager.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,UAAU,EAAW,MAAM,MAAM,CAAC;AAE/D,OAAO,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAOpD,eAAO,MAAM,gBAAgB;;;;0BA8EH,UAAU,EAAE;mBAA2B,MAAM;;;CAkBrE,CAAC"}

package/dist/replay/use-replay-manager.js

@@ -0,0 +1,88 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReplayManager = void 0;
+const rxjs_1 = require("rxjs");
+const use_hash_1 = require("../use-hash");
+const use_logger_1 = require("../use-logger");
+const with_memo_1 = require("../with-memo");
+const use_replay_options_1 = require("./use-replay-options");
+const use_replay_storage_buffer_1 = require("./use-replay-storage-buffer");
+exports.useReplayManager = (0, with_memo_1.withMemo)(() => {
+    const { from, to } = (0, use_replay_options_1.useReplayOptions)();
+    const { info } = (0, use_logger_1.useLogger)('useReplayManager');
+    let timestamp = from;
+    let stopAcquire = 1;
+    const subscriptions = Array.of();
+    const stream$ = new rxjs_1.Subject();
+    const getNextStorage = () => __awaiter(void 0, void 0, void 0, function* () {
+        let next;
+        for (const cursor of subscriptions) {
+            if (cursor.size() == 0 && !cursor.completed()) {
+                yield cursor.fetchNextPage(timestamp, to + 1);
+            }
+            if (cursor.peek()) {
+                if (!next || next.peek().timestamp > cursor.peek().timestamp) {
+                    next = cursor;
+                }
+            }
+        }
+        return next;
+    });
+    const processNext = () => __awaiter(void 0, void 0, void 0, function* () {
+        const cursor = yield getNextStorage();
+        if (!cursor || !cursor.peek()) {
+            stream$.complete();
+            return false;
+        }
+        const sample = cursor.dequeue();
+        timestamp = sample.timestamp;
+        stream$.next([cursor, sample]);
+        return true;
+    });
+    const next = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (yield processNext()) {
+            if (stopAcquire === 0) {
+                setImmediate(next);
+            }
+        }
+    });
+    const tryContinue = () => {
+        if (stopAcquire == 0) {
+            return;
+        }
+        stopAcquire = Math.max(0, stopAcquire - 1);
+        if (stopAcquire != 0) {
+            return;
+        }
+        next();
+    };
+    return {
+        timestamp() {
+            return timestamp;
+        },
+        stop() {
+            stopAcquire++;
+        },
+        tryContinue,
+        when(dependencies) {
+            const storage = (0, use_replay_storage_buffer_1.useReplayStorageBuffer)(dependencies);
+            if (!subscriptions.includes(storage)) {
+                info('subscribing to replay', (0, use_hash_1.useHash)(dependencies));
+                subscriptions.push(storage);
+            }
+            return (0, rxjs_1.defer)(() => {
+                tryContinue();
+                return stream$.pipe((0, rxjs_1.filter)(([cur]) => cur === storage), (0, rxjs_1.map)(([, it]) => ({ timestamp: it.timestamp, payload: it.payload })));
+            });
+        }
+    };
+});

package/dist/replay/use-replay-storage-buffer.d.ts

@@ -0,0 +1,15 @@
+import { dependency } from '../use-hash';
+export declare const useReplayStorageBuffer: <T>(dependencies: dependency[]) => {
+    size(): number;
+    peek(): {
+        timestamp: number;
+        payload: T;
+    };
+    dequeue(): {
+        timestamp: number;
+        payload: T;
+    };
+    completed(): boolean;
+    fetchNextPage(from: number, to: number): Promise<void>;
+};
+//# sourceMappingURL=use-replay-storage-buffer.d.ts.map

package/dist/replay/use-replay-storage-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-replay-storage-buffer.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-storage-buffer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAK3C,eAAO,MAAM,sBAAsB;;;mBAGC,MAAM;;;;mBAAN,MAAM;;;;wBAiBZ,MAAM,MAAM,MAAM;CAgB9C,CAAC"}

package/dist/replay/use-replay-storage-buffer.js

@@ -0,0 +1,50 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReplayStorageBuffer = void 0;
+const storage_1 = require("../storage");
+const with_memo_1 = require("../with-memo");
+const use_replay_storage_1 = require("./use-replay-storage");
+exports.useReplayStorageBuffer = (0, with_memo_1.withMemo)((dependencies) => {
+    const { query } = (0, use_replay_storage_1.useReplayStorage)(dependencies);
+    let page = new Array();
+    let index = 0;
+    let completed = false;
+    return {
+        size() {
+            return page.length - index;
+        },
+        peek() {
+            return page[index];
+        },
+        dequeue() {
+            return page[index++];
+        },
+        completed() {
+            return completed;
+        },
+        fetchNextPage(from, to) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (completed) {
+                    return;
+                }
+                index = 0;
+                page = yield query({
+                    where: {
+                        timestamp: (0, storage_1.between)(from, to)
+                    },
+                    limit: 10000
+                });
+                completed = page.length == 0;
+            });
+        }
+    };
+});

package/dist/replay/use-replay-storage.d.ts

@@ -1,10 +1,13 @@
-import { Storage } from '../storage';
-export declare const replaySerializableObject: (key: string) => {
-    discriminator: string;
-    type: {
-        timestamp: "number";
-        json: "string";
-    };
+import { Query, QueryObject } from '../storage';
+import { dependency } from '../use-hash';
+export declare function useReplayStorage<T>(dependencies: dependency[]): {
+    query(query: Query<QueryObject>): Promise<{
+        timestamp: number;
+        payload: T;
+    }[]>;
+    save(objects: {
+        timestamp: number;
+        payload: T;
+    }[]): Promise<void>;
 };
-export declare function useReplayStorage(): Storage;
 //# sourceMappingURL=use-replay-storage.d.ts.map

package/dist/replay/use-replay-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-replay-storage.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAc,MAAM,cAAc,CAAC;AAEnD,eAAO,MAAM,wBAAwB,QAAS,MAAM;;;;;;CACgB,CAAC;AAErE,wBAAgB,gBAAgB,YAE/B"}
+{"version":3,"file":"use-replay-storage.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAuB,MAAM,cAAc,CAAC;AACvE,OAAO,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAEpD,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,YAAY,EAAE,UAAU,EAAE;iBASvC,MAAM,WAAW,CAAC;;;;kBAMvB;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,CAAC,CAAA;KAAE,EAAE;EAUpD"}

package/dist/replay/use-replay-storage.js

@@ -1,10 +1,39 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useReplayStorage = exports.replaySerializableObject = void 0;
+exports.useReplayStorage = void 0;
 const storage_1 = require("../storage");
-const replaySerializableObject = (key) => storage_1.Storage.createObject(key, { timestamp: 'number', json: 'string' });
-exports.replaySerializableObject = replaySerializableObject;
-function useReplayStorage() {
-    return (0, storage_1.useStorage)(['replay']);
+const use_hash_1 = require("../use-hash");
+function useReplayStorage(dependencies) {
+    const storage = (0, storage_1.useStorage)(['replay']);
+    const storageObjectKey = (0, use_hash_1.useHash)(dependencies);
+    const storageObject = storage_1.Storage.createObject(storageObjectKey, {
+        timestamp: 'number',
+        payload: 'string'
+    });
+    return {
+        query(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return (yield storage.query(storageObject, query)).map(it => ({
+                    timestamp: it.timestamp,
+                    payload: JSON.parse(it.payload)
+                }));
+            });
+        },
+        save(objects) {
+            return storage.save(storageObject, objects.map(it => ({
+                timestamp: it.timestamp,
+                payload: JSON.stringify(it.payload)
+            })));
+        }
+    };
 }
 exports.useReplayStorage = useReplayStorage;

package/dist/replay/use-replay-storage.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=use-replay-storage.spec.d.ts.map

package/dist/replay/use-replay-storage.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-replay-storage.spec.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-storage.spec.ts"],"names":[],"mappings":""}

package/dist/replay/use-replay-storage.spec.js

@@ -0,0 +1,74 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const make_test_module_1 = require("../make-test-module");
+const storage_1 = require("../storage");
+const use_replay_storage_1 = require("./use-replay-storage");
+jest.mock('@lib/storage', () => (Object.assign(Object.assign({}, jest.requireActual('@lib/storage')), { useStorage: jest.fn() })));
+describe(use_replay_storage_1.useReplayStorage.name, () => {
+    let fixtures;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        fixtures = yield getFixtures();
+    }));
+    describe('query', () => {
+        test('happy path', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield fixtures.given.stored(fixtures.sample);
+            const sample = yield fixtures.when.queried({});
+            expect(sample).toEqual(fixtures.sample);
+        }));
+    });
+    describe('save', () => {
+        test('happy path', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield fixtures.when.saved(fixtures.sample);
+            yield fixtures.then.stored(fixtures.sample);
+        }));
+    });
+});
+function getFixtures() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { act } = yield (0, make_test_module_1.makeTestModule)([]);
+        const dependencies = ['binance:btc-usdt', 'candle', 'h1'];
+        const save = jest.fn();
+        const query = jest.fn();
+        (0, make_test_module_1.mockedFunc)(storage_1.useStorage).mockReturnValue({ save, query });
+        return {
+            sample: [
+                { timestamp: 1, payload: { o: 1.1, h: 1.1, l: 1.1, c: 1.1 } },
+                { timestamp: 2, payload: { o: 1.1, h: 2.2, l: 1.1, c: 2.2 } },
+                { timestamp: 3, payload: { o: 1.1, h: 3.3, l: 1.1, c: 3.3 } }
+            ],
+            given: {
+                stored(sample) {
+                    return query.mockReturnValue(Promise.resolve(sample.map(it => ({
+                        timestamp: it.timestamp,
+                        payload: JSON.stringify(it.payload)
+                    }))));
+                }
+            },
+            when: {
+                saved(sample) {
+                    return act(() => (0, use_replay_storage_1.useReplayStorage)(dependencies).save(sample));
+                },
+                queried(query) {
+                    return act(() => (0, use_replay_storage_1.useReplayStorage)(dependencies).query(query));
+                }
+            },
+            then: {
+                stored(sample) {
+                    expect(save).toHaveBeenCalledWith(expect.anything(), sample.map(it => ({
+                        timestamp: it.timestamp,
+                        payload: JSON.stringify(it.payload)
+                    })));
+                }
+            }
+        };
+    });
+}

package/dist/replay/use-replay.d.ts

@@ -1,9 +1,9 @@
 import { Observable } from 'rxjs';
 import { dependency } from '../use-hash';
-export declare const useReplay: <T>(input: Observable<{
+export declare function useReplay<T>(input: Observable<{
     timestamp: number;
     payload: T;
-}>, dependencies: dependency[]) => Observable<{
+}>, dependencies: dependency[]): Observable<{
     timestamp: number;
     payload: T;
 }>;

package/dist/replay/use-replay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-replay.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,UAAU,EAAE,MAAM,MAAM,CAAC;AAIlD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,eAAO,MAAM,SAAS;eACW,MAAM;;kBACvB,UAAU,EAAE;eADK,MAAM;;EAwBtC,CAAC"}
+{"version":3,"file":"use-replay.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAO,MAAM,MAAM,CAAC;AAGvC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAK3C,wBAAgB,SAAS,CAAC,CAAC,EACzB,KAAK,EAAE,UAAU,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,CAAA;CAAE,CAAC,EACpD,YAAY,EAAE,UAAU,EAAE;eADK,MAAM;aAAW,CAAC;GAkBlD"}

package/dist/replay/use-replay.js

@@ -1,32 +1,20 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useReplay = void 0;
 const rxjs_1 = require("rxjs");
-const use_replay_coordinator_1 = require("../replay/use-replay-coordinator");
 const use_execution_mode_1 = require("../use-execution-mode");
-const use_replay_writer_1 = require("./use-replay-writer");
-const useReplay = (input, dependencies) => {
+const use_replay_manager_1 = require("./use-replay-manager");
+const use_replay_storage_1 = require("./use-replay-storage");
+function useReplay(input, dependencies) {
     const { isReplay, recording } = (0, use_execution_mode_1.useExecutionMode)();
     if (isReplay) {
-        const { subscribe } = (0, use_replay_coordinator_1.useReplayCoordinator)();
-        return subscribe(dependencies).pipe((0, rxjs_1.map)(it => it));
+        const { when } = (0, use_replay_manager_1.useReplayManager)();
+        return when(dependencies);
     }
     if (recording) {
-        const writer = (0, use_replay_writer_1.useReplayWriter)(dependencies);
-        return input.pipe((0, rxjs_1.concatMap)((it) => __awaiter(void 0, void 0, void 0, function* () {
-            yield writer([it]);
-            return it;
-        })));
+        const { save } = (0, use_replay_storage_1.useReplayStorage)(dependencies);
+        return input.pipe((0, rxjs_1.tap)(it => save([it])));
     }
     return input;
-};
+}
 exports.useReplay = useReplay;