@quantform/core 0.7.0-beta.8 → 0.7.9

package/{dist → lib}/make-test-module.js

@@ -9,7 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toArray = exports.mockedFunc = exports.makeTestModule = void 0;
+exports.mockedFunc = void 0;
+exports.makeTestModule = makeTestModule;
+exports.toArray = toArray;
+exports.mockSubject = mockSubject;
 const rxjs_1 = require("rxjs");
 const core_1 = require("./core");
 const module_1 = require("./module");
@@ -23,7 +26,6 @@ function makeTestModule(dependencies) {
         };
     });
 }
-exports.makeTestModule = makeTestModule;
 const mockedFunc = (mockedFunc) => mockedFunc;
 exports.mockedFunc = mockedFunc;
 function toArray(observable) {
@@ -40,7 +42,14 @@ function toArray(observable) {
         }
         return it;
     };
-    observable.pipe((0, rxjs_1.tap)(it => array.push(clone(it)))).subscribe();
+    observable.subscribe({
+        next: it => array.push(clone(it)),
+        error: it => array.push(it)
+    });
     return array;
 }
-exports.toArray = toArray;
+function mockSubject(object, method) {
+    const subject = new rxjs_1.Subject();
+    jest.spyOn(object, method).mockReturnValue(subject.asObservable());
+    return subject;
+}

package/lib/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAG1B,OAAO,EAEL,mBAAmB,EACnB,MAAM,EACN,UAAU,EACV,SAAS,EACT,cAAc,EAEf,MAAM,UAAU,CAAC;AAElB,eAAO,MAAM,QAAQ,mBAAa,CAAC;AACnC,eAAO,MAAM,OAAO,eAAS,CAAC;AAC9B,eAAO,MAAM,UAAU,kBAAY,CAAC;AAEpC,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,cAAc,CAAC;IACxB,QAAQ,CAAC,EAAE,GAAG,CAAC;IACf,QAAQ,CAAC,EAAE,GAAG,CAAC;CAChB,CAAC;AAuBF;;GAEG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,cAAc,CAAC,CAAC,CAAC,MAQrD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,YAI5B,CAAC;AAEF;;;GAGG;AACH,qBAAa,MAAM;IAGL,OAAO,CAAC,QAAQ,CAAC,YAAY;IAFzC,OAAO,CAAC,SAAS,CAAC,CAAsB;gBAEX,YAAY,EAAE,UAAU,EAAE;IAEvD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC;QAAE,GAAG,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAA;KAAE,CAAC;IAWxD;;;OAGG;IACH,OAAO;IAQP;;;OAGG;IACH,SAAS,CAAC,cAAc,IAAI,mBAAmB;IAgB/C;;;;;OAKG;IACH,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC;IAYnC;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;CAWzC"}

package/lib/operators.d.ts

@@ -0,0 +1,5 @@
+import { Observable } from 'rxjs';
+export declare function asReadonly<T>(): (input: Observable<T>) => Observable<Readonly<T>>;
+export declare function defined<T>(): (observable: Observable<T | undefined | null>) => Observable<T & {}>;
+export declare function exclude<T, S extends symbol>(s: S): (observable: Observable<T | S>) => Observable<Exclude<T, S>>;
+//# sourceMappingURL=operators.d.ts.map

package/lib/operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.d.ts","sourceRoot":"","sources":["../src/operators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,UAAU,EAAE,MAAM,MAAM,CAAC;AAE/C,wBAAgB,UAAU,CAAC,CAAC,aACX,UAAU,CAAC,CAAC,CAAC,6BAC7B;AAED,wBAAgB,OAAO,CAAC,CAAC,kBACH,UAAU,CAAC,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC,wBAErD;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,gBAC3B,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,+BAKtC"}

package/lib/operators.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asReadonly = asReadonly;
+exports.defined = defined;
+exports.exclude = exclude;
+const rxjs_1 = require("rxjs");
+function asReadonly() {
+    return (input) => input.pipe((0, rxjs_1.map)(it => it));
+}
+function defined() {
+    return (observable) => observable.pipe((0, rxjs_1.filter)(it => it !== undefined && it !== null));
+}
+function exclude(s) {
+    return (observable) => observable.pipe((0, rxjs_1.filter)(it => it !== s), (0, rxjs_1.map)(it => it));
+}

package/lib/replay/index.d.ts

@@ -0,0 +1,10 @@
+export * from './use-replay';
+export * from './use-replay-lock';
+export * from './use-replay-options';
+export * from './storage/use-replay-storage';
+export * from './storage/use-replay-storage-buffer';
+export * from './use-replay-manager';
+export * from './when-replay-finished';
+export * from './replay';
+export * from './replay-guard';
+//# sourceMappingURL=index.d.ts.map

package/lib/replay/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/replay/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qCAAqC,CAAC;AACpD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC"}

package/{dist → lib}/replay/index.js

@@ -15,8 +15,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./use-replay"), exports);
-__exportStar(require("./use-replay-coordinator"), exports);
+__exportStar(require("./use-replay-lock"), exports);
 __exportStar(require("./use-replay-options"), exports);
-__exportStar(require("./use-replay-reader"), exports);
-__exportStar(require("./use-replay-writer"), exports);
-__exportStar(require("./with-replay"), exports);
+__exportStar(require("./storage/use-replay-storage"), exports);
+__exportStar(require("./storage/use-replay-storage-buffer"), exports);
+__exportStar(require("./use-replay-manager"), exports);
+__exportStar(require("./when-replay-finished"), exports);
+__exportStar(require("./replay"), exports);
+__exportStar(require("./replay-guard"), exports);

package/lib/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/lib/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/lib/replay/replay-guard.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replayGuard = replayGuard;
+const use_replay_lock_1 = require("./use-replay-lock");
+function replayGuard(fn) {
+    return (...args) => (0, use_replay_lock_1.useReplayLock)(fn(...args));
+}

package/lib/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/lib/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/lib/replay/replay.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replay = replay;
+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]));
+}

package/lib/replay/storage/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(): Promise<void>;
+};
+//# sourceMappingURL=use-replay-storage-buffer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-replay-storage-buffer.d.ts","sourceRoot":"","sources":["../../../src/replay/storage/use-replay-storage-buffer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAK3C,eAAO,MAAM,sBAAsB,GAAa,CAAC;;;mBAMb,MAAM;iBAAW,CAAC;;;mBAAlB,MAAM;iBAAW,CAAC;;;;CAsCpD,CAAC"}

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

@@ -0,0 +1,57 @@
+"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 use_replay_options_1 = require("../../replay/use-replay-options");
+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);
+    const { from, to } = (0, use_replay_options_1.useReplayOptions)();
+    console.log(from, to);
+    let page = new Array();
+    let index = 0;
+    let completed = false;
+    let count = 0;
+    return {
+        size() {
+            return page.length - index;
+        },
+        peek() {
+            return page[index];
+        },
+        dequeue() {
+            return page[index++];
+        },
+        completed() {
+            return completed;
+        },
+        fetchNextPage() {
+            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,
+                    offset: count,
+                    orderBy: 'ASC'
+                });
+                count += page.length;
+                completed = page.length == 0;
+            });
+        }
+    };
+});

package/lib/replay/storage/use-replay-storage-cursor.d.ts

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

package/lib/replay/storage/use-replay-storage-cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-replay-storage-cursor.d.ts","sourceRoot":"","sources":["../../../src/replay/storage/use-replay-storage-cursor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAMpD,eAAO,MAAM,sBAAsB;QAK3B,CAAC,gBAAgB,UAAU,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCnC,CAAC"}

package/lib/replay/storage/use-replay-storage-cursor.js

@@ -0,0 +1,49 @@
+"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.useReplayStorageCursor = void 0;
+const use_hash_1 = require("../../use-hash");
+const use_logger_1 = require("../../use-logger");
+const with_memo_1 = require("../../with-memo");
+const use_replay_storage_buffer_1 = require("./use-replay-storage-buffer");
+exports.useReplayStorageCursor = (0, with_memo_1.withMemo)(() => {
+    const { info } = (0, use_logger_1.useLogger)('useReplayStorageCursor');
+    const storages = Array.of();
+    return {
+        get(dependencies) {
+            const storage = (0, use_replay_storage_buffer_1.useReplayStorageBuffer)(dependencies);
+            if (!storages.includes(storage)) {
+                info('opening a new replay buffer', (0, use_hash_1.useHash)(dependencies));
+                storages.push(storage);
+            }
+            return storage;
+        },
+        cursor() {
+            return __awaiter(this, void 0, void 0, function* () {
+                let current;
+                for (const storage of storages) {
+                    if (storage.completed()) {
+                        continue;
+                    }
+                    if (storage.size() == 0) {
+                        yield storage.fetchNextPage();
+                    }
+                    if (storage.peek()) {
+                        if (!current || current.peek().timestamp > storage.peek().timestamp) {
+                            current = storage;
+                        }
+                    }
+                }
+                return current;
+            });
+        }
+    };
+});

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

@@ -0,0 +1,13 @@
+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>;
+};
+//# sourceMappingURL=use-replay-storage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-replay-storage.d.ts","sourceRoot":"","sources":["../../../src/replay/storage/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,KAAK,CAAC,WAAW,CAAC;;iBAGE,CAAC;;kBAG1B;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,CAAC,CAAA;KAAE,EAAE;EAUpD"}

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

@@ -0,0 +1,38 @@
+"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 = useReplayStorage;
+const storage_1 = require("../../storage");
+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)
+            })));
+        }
+    };
+}

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

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

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

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

package/lib/replay/storage/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/lib/replay/use-replay-lock.d.ts

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

package/lib/replay/use-replay-lock.d.ts.map

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

package/lib/replay/use-replay-lock.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReplayLock = useReplayLock;
+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 useReplayLock(input) {
+    const { isReplay } = (0, use_execution_mode_1.useExecutionMode)();
+    if (!isReplay) {
+        return input;
+    }
+    const { info } = (0, use_logger_1.useLogger)('replay');
+    const { stop, tryContinue } = (0, use_replay_manager_1.useReplayManager)();
+    info('lock acquired');
+    stop();
+    return input.pipe((0, rxjs_1.finalize)(() => {
+        info('lock released');
+        tryContinue();
+    }));
+}

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

@@ -0,0 +1,28 @@
+import { Observable } from 'rxjs';
+import { dependency } from '../use-hash';
+export declare const useReplayManager: () => {
+    stream: Observable<[{
+        size(): number;
+        peek(): {
+            timestamp: number;
+            payload: any;
+        };
+        dequeue(): {
+            timestamp: number;
+            payload: any;
+        };
+        completed(): boolean;
+        fetchNextPage(): Promise<void>;
+    }, {
+        timestamp: number;
+        payload: any;
+    }]>;
+    timestamp(): number;
+    stop(): void;
+    tryContinue: () => void;
+    watch<T>(dependencies: dependency[]): Observable<{
+        timestamp: number;
+        payload: T;
+    }>;
+};
+//# sourceMappingURL=use-replay-manager.d.ts.map

package/lib/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,EAAE,MAAM,eAAe,CAAC;AAO3C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;mBAQqC,MAAM;iBAAW,GAAG;;;;;UAoD5E,CAAC,gBAAgB,UAAU,EAAE,GAAG,UAAU,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,CAAC,CAAA;KAAE,CAAC;CAarF,CAAC"}

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

@@ -0,0 +1,68 @@
+"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 with_memo_1 = require("../with-memo");
+const use_replay_storage_cursor_1 = require("./storage/use-replay-storage-cursor");
+const use_replay_options_1 = require("./use-replay-options");
+exports.useReplayManager = (0, with_memo_1.withMemo)(() => {
+    const { from } = (0, use_replay_options_1.useReplayOptions)();
+    const { get, cursor } = (0, use_replay_storage_cursor_1.useReplayStorageCursor)();
+    let timestamp = from;
+    let stopAcquire = 1;
+    const stream$ = new rxjs_1.Subject();
+    const processNext = () => __awaiter(void 0, void 0, void 0, function* () {
+        const storage = yield cursor();
+        if (!storage || !storage.peek()) {
+            stream$.complete();
+            return false;
+        }
+        const sample = storage.dequeue();
+        timestamp = sample.timestamp;
+        stream$.next([storage, 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 {
+        stream: stream$.asObservable(),
+        timestamp() {
+            return timestamp;
+        },
+        stop() {
+            stopAcquire++;
+        },
+        tryContinue,
+        watch(dependencies) {
+            const storage = get(dependencies);
+            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 → lib}/replay/use-replay-options.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useReplayOptions = exports.replayOptions = void 0;
+exports.useReplayOptions = void 0;
+exports.replayOptions = replayOptions;
 const module_1 = require("../module");
 const injectionToken = Symbol('replay-options');
 /**
@@ -12,7 +13,6 @@ function replayOptions(options) {
         useValue: options
     };
 }
-exports.replayOptions = replayOptions;
 /**
  * Will return current replay execution options.
  */

package/{dist → lib}/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/lib/replay/use-replay.d.ts.map

@@ -0,0 +1 @@
+{"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/lib/replay/use-replay.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReplay = useReplay;
+const rxjs_1 = require("rxjs");
+const use_execution_mode_1 = require("../use-execution-mode");
+const use_replay_storage_1 = require("./storage/use-replay-storage");
+const use_replay_manager_1 = require("./use-replay-manager");
+function useReplay(input, dependencies) {
+    const { isReplay, recording } = (0, use_execution_mode_1.useExecutionMode)();
+    if (isReplay) {
+        const { watch } = (0, use_replay_manager_1.useReplayManager)();
+        return watch(dependencies);
+    }
+    if (recording) {
+        const { save } = (0, use_replay_storage_1.useReplayStorage)(dependencies);
+        return input.pipe((0, rxjs_1.tap)(it => save([it])));
+    }
+    return input;
+}