@quantform/core 0.7.0-beta.33 → 0.7.0-beta.34

package/src/replay/use-replay-storage.spec.ts

@@ -0,0 +1,85 @@
+import { makeTestModule, mockedFunc } from '@lib/make-test-module';
+import { Query, QueryObject, Storage } from '@lib/storage';
+import { useStorage } from '@lib/storage';
+
+import { useReplayStorage } from './use-replay-storage';
+
+jest.mock('@lib/storage', () => ({
+  ...jest.requireActual('@lib/storage'),
+  useStorage: jest.fn()
+}));
+
+describe(useReplayStorage.name, () => {
+  let fixtures: Awaited<ReturnType<typeof getFixtures>>;
+
+  beforeEach(async () => {
+    fixtures = await getFixtures();
+  });
+
+  describe('query', () => {
+    test('happy path', async () => {
+      await fixtures.given.stored(fixtures.sample);
+      const sample = await fixtures.when.queried({});
+
+      expect(sample).toEqual(fixtures.sample);
+    });
+  });
+
+  describe('save', () => {
+    test('happy path', async () => {
+      await fixtures.when.saved(fixtures.sample);
+      await fixtures.then.stored(fixtures.sample);
+    });
+  });
+});
+
+async function getFixtures() {
+  const { act } = await makeTestModule([]);
+
+  const dependencies = ['binance:btc-usdt', 'candle', 'h1'];
+  const save: Storage['save'] = jest.fn();
+  const query: jest.MockedFunction<Storage['query']> = jest.fn();
+
+  mockedFunc(useStorage).mockReturnValue({ save, query } as any);
+
+  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<T>(sample: { timestamp: number; payload: T }[]) {
+        return query.mockReturnValue(
+          Promise.resolve(
+            sample.map(it => ({
+              timestamp: it.timestamp,
+              payload: JSON.stringify(it.payload)
+            }))
+          )
+        );
+      }
+    },
+    when: {
+      saved<T>(sample: { timestamp: number; payload: T }[]) {
+        return act(() => useReplayStorage(dependencies).save(sample));
+      },
+      queried<T>(query: Query<QueryObject>) {
+        return act(() => useReplayStorage<T>(dependencies).query(query));
+      }
+    },
+
+    then: {
+      stored<T>(sample: { timestamp: number; payload: T }[]) {
+        expect(save).toHaveBeenCalledWith(
+          expect.anything(),
+          sample.map(it => ({
+            timestamp: it.timestamp,
+            payload: JSON.stringify(it.payload)
+          }))
+        );
+      }
+    }
+  };
+}

package/src/replay/use-replay-storage.ts

@@ -1,8 +1,29 @@
-import { Storage, useStorage } from '@lib/storage';
+import { Query, QueryObject, Storage, useStorage } from '@lib/storage';
+import { dependency, useHash } from '@lib/use-hash';
 
-export const replaySerializableObject = (key: string) =>
-  Storage.createObject(key, { timestamp: 'number', json: 'string' });
+export function useReplayStorage<T>(dependencies: dependency[]) {
+  const storage = useStorage(['replay']);
+  const storageObjectKey = useHash(dependencies);
+  const storageObject = Storage.createObject(storageObjectKey, {
+    timestamp: 'number',
+    payload: 'string'
+  });
 
-export function useReplayStorage() {
-  return useStorage(['replay']);
+  return {
+    async query(query: Query<QueryObject>) {
+      return (await storage.query(storageObject, query)).map(it => ({
+        timestamp: it.timestamp,
+        payload: JSON.parse(it.payload) as T
+      }));
+    },
+    save(objects: { timestamp: number; payload: T }[]) {
+      return storage.save(
+        storageObject,
+        objects.map(it => ({
+          timestamp: it.timestamp,
+          payload: JSON.stringify(it.payload)
+        }))
+      );
+    }
+  };
 }

package/src/replay/use-replay.spec.ts

@@ -1,15 +1,21 @@
+import exp from 'constants';
 import { from, lastValueFrom, tap } from 'rxjs';
 
 import { makeTestModule } from '@lib/make-test-module';
-import { useReplayCoordinator } from '@lib/replay/use-replay-coordinator';
 import { replayExecutionMode } from '@lib/use-execution-mode';
 import { dependency } from '@lib/use-hash';
 
 import { between } from '..';
 import { useReplay } from './use-replay';
 import { replayOptions } from './use-replay-options';
-import { useReplayReader } from './use-replay-reader';
-import { useReplayWriter } from './use-replay-writer';
+
+describe(useReplay.name, () => {
+  test('happy path', () => {
+    expect(true).toBe(true);
+  });
+});
+
+/*
 
 describe.skip(useReplayCoordinator.name, () => {
   let fixtures: Awaited<ReturnType<typeof getFixtures>>;
@@ -130,3 +136,4 @@ async function getFixtures() {
     }
   };
 }
+*/

package/src/replay/use-replay.ts

@@ -1,34 +1,28 @@
-import { concatMap, map, Observable } from 'rxjs';
+import { Observable, tap } from 'rxjs';
 
-import { useReplayCoordinator } from '@lib/replay/use-replay-coordinator';
 import { useExecutionMode } from '@lib/use-execution-mode';
 import { dependency } from '@lib/use-hash';
 
-import { useReplayWriter } from './use-replay-writer';
+import { useReplayManager } from './use-replay-manager';
+import { useReplayStorage } from './use-replay-storage';
 
-export const useReplay = <T>(
+export function useReplay<T>(
   input: Observable<{ timestamp: number; payload: T }>,
   dependencies: dependency[]
-) => {
+) {
   const { isReplay, recording } = useExecutionMode();
 
   if (isReplay) {
-    const { subscribe } = useReplayCoordinator();
+    const { when } = useReplayManager();
 
-    return subscribe(dependencies).pipe(
-      map(it => it as unknown as { timestamp: number; payload: T })
-    );
+    return when<T>(dependencies);
   }
 
   if (recording) {
-    const writer = useReplayWriter(dependencies);
-    return input.pipe(
-      concatMap(async it => {
-        await writer([it]);
-        return it;
-      })
-    );
+    const { save } = useReplayStorage<T>(dependencies);
+
+    return input.pipe(tap(it => save([it])));
   }
 
   return input;
-};
+}

package/src/storage/index.ts

@@ -1,4 +1,5 @@
 export * from './storage';
+export * from './use-cache';
 export * from './use-storage';
 export * from './use-storage-factory';
 export * from './in-memory';

package/src/use-execution-mode.ts

@@ -3,28 +3,28 @@ import { useContext } from '@lib/module';
 const injectionToken = Symbol('execution-mode');
 
 type ExecutionMode = {
-  mode: 'REPLAY' | 'PAPER' | 'LIVE';
+  mode: 'replay' | 'paper' | 'live';
   recording: boolean;
 };
 
 export function replayExecutionMode() {
   return {
     provide: injectionToken,
-    useValue: { mode: 'REPLAY', recording: false } as ExecutionMode
+    useValue: { mode: 'replay', recording: false } as ExecutionMode
   };
 }
 
 export function paperExecutionMode(options: { recording: boolean }) {
   return {
     provide: injectionToken,
-    useValue: { mode: 'PAPER', ...options } as ExecutionMode
+    useValue: { mode: 'paper', ...options } as ExecutionMode
   };
 }
 
 export function liveExecutionMode(options: { recording: boolean }) {
   return {
     provide: injectionToken,
-    useValue: { mode: 'LIVE', ...options } as ExecutionMode
+    useValue: { mode: 'live', ...options } as ExecutionMode
   };
 }
 
@@ -32,10 +32,10 @@ export const useExecutionMode = () => {
   const mode = useContext<ExecutionMode>(injectionToken);
 
   return {
-    isReplay: mode.mode === 'REPLAY',
-    isPaper: mode.mode === 'PAPER',
-    isLive: mode.mode === 'LIVE',
-    isSimulation: mode.mode !== 'LIVE',
+    isReplay: mode.mode === 'replay',
+    isPaper: mode.mode === 'paper',
+    isLive: mode.mode === 'live',
+    isSimulation: mode.mode !== 'live',
     recording: mode.recording
   };
 };

package/src/use-timestamp.ts

@@ -1,11 +1,11 @@
-import { useReplayCoordinator } from '@lib/replay/use-replay-coordinator';
+import { useReplayManager } from '@lib/replay';
 import { useExecutionMode } from '@lib/use-execution-mode';
 
 export function useTimestamp() {
   const { isReplay } = useExecutionMode();
 
   if (isReplay) {
-    return useReplayCoordinator().timestamp();
+    return useReplayManager().timestamp();
   }
 
   return Date.now();

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

@@ -1,10 +0,0 @@
-import { dependency } from '../use-hash';
-export declare function useReplayCoordinator(): {
-    timestamp: () => number;
-    stop: () => number;
-    tryContinue: () => void;
-    subscribe: (dependencies: dependency[]) => import("rxjs").Observable<{
-        timestamp: number;
-    }>;
-};
-//# sourceMappingURL=use-replay-coordinator.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-replay-coordinator.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-coordinator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAO3C,wBAAgB,oBAAoB;;;;8BAUC,UAAU,EAAE;mBAFW,MAAM;;EAsFjE"}

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

@@ -1,119 +0,0 @@
-"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.useReplayCoordinator = void 0;
-const rxjs_1 = require("rxjs");
-const use_memo_1 = require("../use-memo");
-const __1 = require("..");
-const use_replay_options_1 = require("./use-replay-options");
-const use_replay_reader_1 = require("./use-replay-reader");
-function useReplayCoordinator() {
-    const options = (0, use_replay_options_1.useReplayOptions)();
-    return (0, use_memo_1.useMemo)(() => {
-        let timestamp = options.from;
-        let stopAcquire = 1;
-        let sequence = 0;
-        const subscriptions = Array.of();
-        const stream$ = new rxjs_1.Subject();
-        const subscribe = (dependencies) => {
-            const cursor = useSampleCursor(dependencies);
-            if (!subscriptions.includes(cursor)) {
-                subscriptions.push(cursor);
-            }
-            return (0, rxjs_1.defer)(() => {
-                tryContinue();
-                return stream$.pipe((0, rxjs_1.filter)(([cur]) => cur === cursor), (0, rxjs_1.map)(([, it]) => it));
-            });
-        };
-        const current = () => __awaiter(this, void 0, void 0, function* () {
-            let next;
-            for (const cursor of subscriptions) {
-                if (cursor.size() == 0 && !cursor.completed) {
-                    yield cursor.fetchNextPage(timestamp, options.to + 1);
-                }
-                if (cursor.peek()) {
-                    if (!next || next.peek().timestamp > cursor.peek().timestamp) {
-                        next = cursor;
-                    }
-                }
-            }
-            return next;
-        });
-        const processNext = () => __awaiter(this, void 0, void 0, function* () {
-            const cursor = yield current();
-            if (!cursor || !cursor.peek()) {
-                stream$.complete();
-                return false;
-            }
-            const sample = cursor.dequeue();
-            timestamp = sample.timestamp;
-            sequence++;
-            stream$.next([cursor, sample]);
-            return true;
-        });
-        const next = () => __awaiter(this, void 0, void 0, function* () {
-            if (yield processNext()) {
-                if (stopAcquire === 0) {
-                    setImmediate(next);
-                }
-            }
-        });
-        const stop = () => stopAcquire++;
-        const tryContinue = () => {
-            if (stopAcquire == 0) {
-                return;
-            }
-            stopAcquire = Math.max(0, stopAcquire - 1);
-            if (stopAcquire != 0) {
-                return;
-            }
-            next();
-        };
-        return {
-            timestamp: () => timestamp,
-            stop,
-            tryContinue,
-            subscribe
-        };
-    }, [useReplayCoordinator.name]);
-}
-exports.useReplayCoordinator = useReplayCoordinator;
-function useSampleCursor(dependencies) {
-    return (0, use_memo_1.useMemo)(() => {
-        const read = (0, use_replay_reader_1.useReplayReader)(dependencies);
-        let page = new Array();
-        let index = 0;
-        let completed = false;
-        const size = () => page.length - index;
-        const peek = () => page[index];
-        const dequeue = () => page[index++];
-        const fetchNextPage = (from, to) => __awaiter(this, void 0, void 0, function* () {
-            if (completed) {
-                return;
-            }
-            index = 0;
-            page = yield read({
-                where: {
-                    timestamp: (0, __1.between)(from, to)
-                },
-                limit: 10000
-            });
-            completed = page.length == 0;
-        });
-        return {
-            size,
-            peek,
-            dequeue,
-            fetchNextPage,
-            completed
-        };
-    }, [useSampleCursor.name, ...dependencies]);
-}

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

@@ -1,7 +0,0 @@
-import { Query, QueryObject } from '../storage';
-import { dependency } from '../use-hash';
-export declare function useReplayReader<T>(dependencies: dependency[]): (query: Query<QueryObject>) => Promise<{
-    timestamp: number;
-    payload: T;
-}[]>;
-//# sourceMappingURL=use-replay-reader.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-replay-reader.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAIpD,wBAAgB,eAAe,CAAC,CAAC,EAAE,YAAY,EAAE,UAAU,EAAE,WAItC,MAAM,WAAW,CAAC;;;KAaxC"}

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

@@ -1,32 +0,0 @@
-"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.useReplayReader = void 0;
-const use_hash_1 = require("../use-hash");
-const use_replay_storage_1 = require("./use-replay-storage");
-function useReplayReader(dependencies) {
-    const storage = (0, use_replay_storage_1.useReplayStorage)();
-    const key = (0, use_hash_1.useHash)(dependencies);
-    return (query) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        return (yield storage.query((0, use_replay_storage_1.replaySerializableObject)(key), {
-            where: {
-                timestamp: (_a = query.where) === null || _a === void 0 ? void 0 : _a.timestamp
-            },
-            limit: query.limit,
-            orderBy: query.orderBy
-        })).map(it => ({
-            timestamp: it.timestamp,
-            payload: JSON.parse(it.json)
-        }));
-    });
-}
-exports.useReplayReader = useReplayReader;

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

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

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

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

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

@@ -1,58 +0,0 @@
-"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_reader_1 = require("./use-replay-reader");
-const use_replay_storage_1 = require("./use-replay-storage");
-jest.mock('./use-replay-storage', () => (Object.assign(Object.assign({}, jest.requireActual('./use-replay-storage')), { useReplayStorage: jest.fn() })));
-describe(use_replay_reader_1.useReplayReader.name, () => {
-    let fixtures;
-    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
-        fixtures = yield getFixtures();
-    }));
-    test('read sample candle data from storage', () => __awaiter(void 0, void 0, void 0, function* () {
-        yield fixtures.givenDataStored(fixtures.sample);
-        const data = yield fixtures.whenDataRequested();
-        expect(data).toEqual(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 query = jest.fn();
-        (0, make_test_module_1.mockedFunc)(use_replay_storage_1.useReplayStorage).mockReturnValue({ 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 } }
-            ],
-            givenDataStored(data) {
-                return query.mockReturnValue(Promise.resolve(data.map(it => ({
-                    kind: 'sample',
-                    timestamp: it.timestamp,
-                    json: JSON.stringify(it.payload)
-                }))));
-            },
-            whenDataRequested() {
-                return __awaiter(this, void 0, void 0, function* () {
-                    return yield act(() => (0, use_replay_reader_1.useReplayReader)(dependencies)({
-                        where: {
-                            timestamp: (0, storage_1.gt)(0)
-                        }
-                    }));
-                });
-            }
-        };
-    });
-}

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

@@ -1,6 +0,0 @@
-import { dependency } from '../use-hash';
-export declare function useReplayWriter<T>(dependencies: dependency[]): (samples: {
-    timestamp: number;
-    payload: T;
-}[]) => Promise<void>;
-//# sourceMappingURL=use-replay-writer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-replay-writer.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-writer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAIpD,wBAAgB,eAAe,CAAC,CAAC,EAAE,YAAY,EAAE,UAAU,EAAE,aAI1C;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,CAAA;CAAE,EAAE,mBAQrD"}

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

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useReplayWriter = void 0;
-const use_hash_1 = require("../use-hash");
-const use_replay_storage_1 = require("./use-replay-storage");
-function useReplayWriter(dependencies) {
-    const storage = (0, use_replay_storage_1.useReplayStorage)();
-    const key = (0, use_hash_1.useHash)(dependencies);
-    return (samples) => storage.save((0, use_replay_storage_1.replaySerializableObject)(key), samples.map(it => ({
-        timestamp: it.timestamp,
-        json: JSON.stringify(it.payload)
-    })));
-}
-exports.useReplayWriter = useReplayWriter;

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

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

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

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

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

@@ -1,53 +0,0 @@
-"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 use_hash_1 = require("../use-hash");
-const use_replay_storage_1 = require("./use-replay-storage");
-const use_replay_writer_1 = require("./use-replay-writer");
-jest.mock('./use-replay-storage', () => (Object.assign(Object.assign({}, jest.requireActual('./use-replay-storage')), { useReplayStorage: jest.fn() })));
-describe.skip(use_replay_writer_1.useReplayWriter.name, () => {
-    let fixtures;
-    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
-        fixtures = yield getFixtures();
-    }));
-    test('write sample candle data to storage', () => __awaiter(void 0, void 0, void 0, function* () {
-        yield fixtures.whenReplayDataWritten(fixtures.sample);
-        yield fixtures.thenReplayDataSaved(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();
-        (0, make_test_module_1.mockedFunc)(use_replay_storage_1.useReplayStorage).mockReturnValue({ save });
-        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 } }
-            ],
-            whenReplayDataWritten(data) {
-                return act(() => (0, use_replay_writer_1.useReplayWriter)(dependencies)(data));
-            },
-            thenReplayDataSaved(data) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    expect(save).toHaveBeenCalledWith((0, use_hash_1.useHash)(dependencies), data.map(it => ({
-                        kind: 'sample',
-                        timestamp: it.timestamp,
-                        json: JSON.stringify(it.payload)
-                    })));
-                });
-            }
-        };
-    });
-}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"with-replay.d.ts","sourceRoot":"","sources":["../../src/replay/with-replay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAElC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,wBAAgB,UAAU,CAAC,CAAC,SAAS,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,EAChF,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,GACpB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAEnB"}

package/dist/replay/with-replay.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withReplay = void 0;
-const with_memo_1 = require("../with-memo");
-function withReplay(fn) {
-    return (0, with_memo_1.withMemo)(fn);
-}
-exports.withReplay = withReplay;