@quantform/core 0.7.22 → 0.7.25

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

@@ -1,7 +1,8 @@
 import { Dependency } from '../module';
+import { Timestamp } from '../use-timestamp';
 type ReplayOptions = {
-    from: number;
-    to: number;
+    from: Timestamp<'ns'>;
+    to: Timestamp<'ns'>;
     limit?: number;
     storage?: string;
 };
@@ -9,8 +10,8 @@ type ReplayOptions = {
  *
  */
 export declare function replayOptions(options: Omit<ReplayOptions, 'from' | 'to'> & {
-    from: number;
-    to: number;
+    from: Timestamp<'ns'>;
+    to: Timestamp<'ns'>;
 }): Dependency;
 /**
  * Will return current replay execution options.

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

@@ -1 +1 @@
-{"version":3,"file":"use-replay-options.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAc,MAAM,aAAa,CAAC;AAIrD,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACzE,UAAU,CASZ;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,qBAAkD,CAAC"}
+{"version":3,"file":"use-replay-options.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAc,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAI/C,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;IACtB,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC,GAAG;IAC5C,IAAI,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;IACtB,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;CACrB,GACA,UAAU,CASZ;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,qBAAkD,CAAC"}

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

@@ -9,7 +9,11 @@ const injectionToken = Symbol('replay-options');
 function replayOptions(options) {
     return {
         provide: injectionToken,
-        useValue: Object.assign({ storage: 'backtest', limit: 10000 }, options)
+        useValue: {
+            storage: 'backtest',
+            limit: 10000,
+            ...options
+        }
     };
 }
 exports.replayOptions = replayOptions;

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

@@ -1,27 +1,28 @@
 import { Observable } from 'rxjs';
+import { Timestamp } from '../use-timestamp';
 import { ReplayQuery } from './use-replay-storage-cursor';
-export declare const useReplayScheduler: () => {
+export declare function useReplayScheduler(): {
     stream: Observable<[{
         size(): number;
         peek(): {
-            timestamp: number;
+            timestamp: Timestamp<"ns">;
             payload: any;
         };
         dequeue(): {
-            timestamp: number;
+            timestamp: Timestamp<"ns">;
             payload: any;
         };
         completed(): boolean;
         fetchNextPage(): Promise<void>;
     }, {
-        timestamp: number;
+        timestamp: Timestamp<'ns'>;
         payload: any;
     }]>;
-    timestamp(): number;
+    timestamp(): Timestamp<"ns">;
     stop(): void;
     tryContinue: () => void;
     watch<T>(query: ReplayQuery<T>): Observable<{
-        timestamp: number;
+        timestamp: Timestamp<'ns'>;
         payload: T;
     }>;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"use-replay-scheduler.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,UAAU,EAAW,MAAM,MAAM,CAAC;AAM/D,OAAO,EAAE,WAAW,EAA0B,MAAM,6BAA6B,CAAC;AAElF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;mBASmC,MAAM;iBAAW,GAAG;;;;;;mBA+DzB,MAAM;;;CAgBjE,CAAC"}
+{"version":3,"file":"use-replay-scheduler.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,UAAU,EAAW,MAAM,MAAM,CAAC;AAG/D,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAI/C,OAAO,EAAE,WAAW,EAA0B,MAAM,6BAA6B,CAAC;AAElF,wBAAgB,kBAAkB;;;;;;;;;;;;;;mBAYb,UAAU,IAAI,CAAC;iBAAW,GAAG;;;;;;mBAkEjB,UAAU,IAAI,CAAC;;;EAiB/C"}

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

@@ -1,77 +1,71 @@
 "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.useReplayScheduler = void 0;
 const rxjs_1 = require("rxjs");
-const with_memo_1 = require("../with-memo");
+const use_memo_1 = require("../use-memo");
 const use_replay_options_1 = require("./use-replay-options");
 const use_replay_storage_cursor_1 = require("./use-replay-storage-cursor");
-exports.useReplayScheduler = (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;
-    let processing = false;
-    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 (processing) {
-            return;
-        }
-        processing = true;
-        while (stopAcquire === 0) {
-            if (!(yield processNext())) {
-                break;
+function useReplayScheduler() {
+    return (0, use_memo_1.useMemo)(() => {
+        const { from } = (0, use_replay_options_1.useReplayOptions)();
+        const { get, cursor } = (0, use_replay_storage_cursor_1.useReplayStorageCursor)();
+        let timestamp = from;
+        let stopAcquire = 1;
+        let processing = false;
+        const stream$ = new rxjs_1.Subject();
+        const processNext = async () => {
+            const storage = await cursor();
+            if (!storage || !storage.peek()) {
+                stream$.complete();
+                return false;
             }
-            yield new Promise(it => setImmediate(it));
-        }
-        processing = false;
-    });
-    const tryContinue = () => {
-        if (stopAcquire === 0) {
-            return;
-        }
-        stopAcquire--;
-        if (stopAcquire === 0) {
-            next();
-        }
-    };
-    return {
-        stream: stream$.asObservable(),
-        timestamp() {
-            return timestamp;
-        },
-        stop() {
-            stopAcquire++;
-        },
-        tryContinue,
-        watch(query) {
-            const storage = get(query);
-            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
-                })));
-            });
-        }
-    };
-});
+            const sample = storage.dequeue();
+            timestamp = sample.timestamp;
+            stream$.next([storage, sample]);
+            return true;
+        };
+        const next = async () => {
+            if (processing) {
+                return;
+            }
+            processing = true;
+            while (stopAcquire === 0) {
+                if (!(await processNext())) {
+                    break;
+                }
+                await new Promise(it => setImmediate(it));
+            }
+            processing = false;
+        };
+        const tryContinue = () => {
+            if (stopAcquire === 0) {
+                return;
+            }
+            stopAcquire--;
+            if (stopAcquire === 0) {
+                next();
+            }
+        };
+        return {
+            stream: stream$.asObservable(),
+            timestamp() {
+                return timestamp;
+            },
+            stop() {
+                stopAcquire++;
+            },
+            tryContinue,
+            watch(query) {
+                const storage = get(query);
+                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
+                    })));
+                });
+            }
+        };
+    }, [useReplayScheduler.name]);
+}
+exports.useReplayScheduler = useReplayScheduler;

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

@@ -1,12 +1,13 @@
+import { Timestamp } from '../use-timestamp';
 import { ReplayQuery } from './use-replay-storage-cursor';
 export declare function useReplayStorageBuffer<T>(storage: ReplayQuery<T>): {
     size(): number;
     peek(): {
-        timestamp: number;
+        timestamp: Timestamp<'ns'>;
         payload: T;
     };
     dequeue(): {
-        timestamp: number;
+        timestamp: Timestamp<'ns'>;
         payload: T;
     };
     completed(): boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"use-replay-storage-buffer.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-storage-buffer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE1D,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC;;;mBAGlC,MAAM;iBAAW,CAAC;;;mBAAlB,MAAM;iBAAW,CAAC;;;;EAwChD"}
+{"version":3,"file":"use-replay-storage-buffer.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-storage-buffer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAG/C,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE1D,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC;;;mBAGlC,UAAU,IAAI,CAAC;iBAAW,CAAC;;;mBAA3B,UAAU,IAAI,CAAC;iBAAW,CAAC;;;;EAwCzD"}

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

@@ -1,13 +1,4 @@
 "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");
@@ -31,21 +22,19 @@ function useReplayStorageBuffer(storage) {
         completed() {
             return completed;
         },
-        fetchNextPage() {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (completed) {
-                    return;
-                }
-                index = 0;
-                page = yield storage.query({
-                    where: { timestamp: (0, storage_1.between)(from, to) },
-                    limit,
-                    offset: count,
-                    orderBy: 'ASC'
-                });
-                count += page.length;
-                completed = page.length === 0;
+        async fetchNextPage() {
+            if (completed) {
+                return;
+            }
+            index = 0;
+            page = await storage.query({
+                where: { timestamp: (0, storage_1.between)(from, to) },
+                limit,
+                offset: count,
+                orderBy: 'ASC'
             });
+            count += page.length;
+            completed = page.length === 0;
         }
     };
 }

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

@@ -1,27 +1,28 @@
 import { Query, QueryObject } from '../storage';
+import { Timestamp } from '../use-timestamp';
 export interface ReplayQuery<V> {
     query(query: Query<QueryObject> & {
         where: {
             timestamp: {
                 type: 'between';
-                min: number;
-                max: number;
+                min: Timestamp<'ns'>;
+                max: Timestamp<'ns'>;
             };
         };
     }): Promise<{
-        timestamp: number;
+        timestamp: Timestamp<'ns'>;
         payload: V;
     }[]>;
 }
-export declare const useReplayStorageCursor: () => {
+export declare function useReplayStorageCursor(): {
     get<T>(query: ReplayQuery<T>): {
         size(): number;
         peek(): {
-            timestamp: number;
+            timestamp: Timestamp<"ns">;
             payload: T;
         };
         dequeue(): {
-            timestamp: number;
+            timestamp: Timestamp<"ns">;
             payload: T;
         };
         completed(): boolean;
@@ -30,11 +31,11 @@ export declare const useReplayStorageCursor: () => {
     cursor(): Promise<{
         size(): number;
         peek(): {
-            timestamp: number;
+            timestamp: Timestamp<"ns">;
             payload: any;
         };
         dequeue(): {
-            timestamp: number;
+            timestamp: Timestamp<"ns">;
             payload: any;
         };
         completed(): boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"use-replay-storage-cursor.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-storage-cursor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAKlD,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,KAAK,CACH,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,GAAG;QAC1B,KAAK,EAAE;YAAE,SAAS,EAAE;gBAAE,IAAI,EAAE,SAAS,CAAC;gBAAC,GAAG,EAAE,MAAM,CAAC;gBAAC,GAAG,EAAE,MAAM,CAAA;aAAE,CAAA;SAAE,CAAC;KACrE,GACA,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,CAAC,CAAA;KAAE,EAAE,CAAC,CAAC;CACjD;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCjC,CAAC"}
+{"version":3,"file":"use-replay-storage-cursor.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-storage-cursor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAI/C,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,KAAK,CACH,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,GAAG;QAC1B,KAAK,EAAE;YACL,SAAS,EAAE;gBAAE,IAAI,EAAE,SAAS,CAAC;gBAAC,GAAG,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;gBAAC,GAAG,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;aAAE,CAAC;SAC5E,CAAC;KACH,GACA,OAAO,CAAC;QAAE,SAAS,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;QAAC,OAAO,EAAE,CAAC,CAAA;KAAE,EAAE,CAAC,CAAC;CAC1D;AAED,wBAAgB,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCrC"}

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

@@ -1,34 +1,25 @@
 "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 with_memo_1 = require("../with-memo");
+const use_memo_1 = require("../use-memo");
 const use_replay_storage_buffer_1 = require("./use-replay-storage-buffer");
-exports.useReplayStorageCursor = (0, with_memo_1.withMemo)(() => {
-    const cursors = Array.of();
-    return {
-        get(query) {
-            const buffer = (0, use_replay_storage_buffer_1.useReplayStorageBuffer)(query);
-            cursors.push(buffer);
-            return buffer;
-        },
-        cursor() {
-            return __awaiter(this, void 0, void 0, function* () {
+function useReplayStorageCursor() {
+    return (0, use_memo_1.useMemo)(() => {
+        const cursors = Array.of();
+        return {
+            get(query) {
+                const buffer = (0, use_replay_storage_buffer_1.useReplayStorageBuffer)(query);
+                cursors.push(buffer);
+                return buffer;
+            },
+            async cursor() {
                 let current;
                 for (const cursor of cursors) {
                     if (cursor.completed()) {
                         continue;
                     }
                     if (cursor.size() == 0) {
-                        yield cursor.fetchNextPage();
+                        await cursor.fetchNextPage();
                     }
                     if (cursor.peek()) {
                         if (!current || current.peek().timestamp > cursor.peek().timestamp) {
@@ -37,7 +28,8 @@ exports.useReplayStorageCursor = (0, with_memo_1.withMemo)(() => {
                     }
                 }
                 return current;
-            });
-        }
-    };
-});
+            }
+        };
+    }, [useReplayStorageCursor.name]);
+}
+exports.useReplayStorageCursor = useReplayStorageCursor;

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

@@ -1,24 +1,25 @@
 import { InferQueryObject, Query, QueryObject, QueryObjectType } from '../storage';
 import { Uri } from '../uri';
+import { Timestamp } from '../use-timestamp';
 export type ReplayStorageQuery<V> = {
     sync: <T extends QueryObjectType<K>, K extends QueryObject>(query: Query<InferQueryObject<T>> & {
         where: {
             timestamp: {
                 type: 'between';
-                min: number;
-                max: number;
+                min: Timestamp<'ns'>;
+                max: Timestamp<'ns'>;
             };
         };
     }, storage: {
         save: (objects: {
-            timestamp: number;
+            timestamp: Timestamp<'ns'>;
             payload: V;
         }[]) => Promise<void>;
     }) => Promise<void>;
 };
 export declare function useReplayStorage<V, P extends Record<string, string | number>>(uri: Uri<P>, { sync }: ReplayStorageQuery<V>): {
     watch: () => import("rxjs").Observable<{
-        timestamp: number;
+        timestamp: Timestamp<"ns">;
         payload: V;
     }>;
 };

package/lib/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":"AAGA,OAAO,EAEL,gBAAgB,EAChB,KAAK,EACL,WAAW,EACX,eAAe,EAGhB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAO/B,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI;IAClC,IAAI,EAAE,CAAC,CAAC,SAAS,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EACxD,KAAK,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,GAAG;QAClC,KAAK,EAAE;YAAE,SAAS,EAAE;gBAAE,IAAI,EAAE,SAAS,CAAC;gBAAC,GAAG,EAAE,MAAM,CAAC;gBAAC,GAAG,EAAE,MAAM,CAAA;aAAE,CAAA;SAAE,CAAC;KACrE,EACD,OAAO,EAAE;QAAE,IAAI,EAAE,CAAC,OAAO,EAAE;YAAE,SAAS,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,CAAC,CAAA;SAAE,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,KAC/E,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB,CAAC;AASF,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EAC3E,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,EACX,EAAE,IAAI,EAAE,EAAE,kBAAkB,CAAC,CAAC,CAAC;;;;;EA+DhC"}
+{"version":3,"file":"use-replay-storage.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-storage.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,gBAAgB,EAChB,KAAK,EACL,WAAW,EACX,eAAe,EAGhB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAG/B,OAAO,EAAM,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAKnD,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI;IAClC,IAAI,EAAE,CAAC,CAAC,SAAS,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EACxD,KAAK,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,GAAG;QAClC,KAAK,EAAE;YACL,SAAS,EAAE;gBAAE,IAAI,EAAE,SAAS,CAAC;gBAAC,GAAG,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;gBAAC,GAAG,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;aAAE,CAAC;SAC5E,CAAC;KACH,EACD,OAAO,EAAE;QACP,IAAI,EAAE,CAAC,OAAO,EAAE;YAAE,SAAS,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;YAAC,OAAO,EAAE,CAAC,CAAA;SAAE,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;KAChF,KACE,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB,CAAC;AASF,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EAC3E,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,EACX,EAAE,IAAI,EAAE,EAAE,kBAAkB,CAAC,CAAC,CAAC;;;;;EAmEhC"}

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

@@ -1,13 +1,4 @@
 "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 = void 0;
 const rxjs_1 = require("rxjs");
@@ -15,47 +6,46 @@ const hash_code_1 = require("../hash-code");
 const storage_1 = require("../storage");
 const use_logger_1 = require("../use-logger");
 const use_memo_1 = require("../use-memo");
+const use_timestamp_1 = require("../use-timestamp");
 const use_replay_options_1 = require("./use-replay-options");
 const use_replay_scheduler_1 = require("./use-replay-scheduler");
 const storageIndexObject = storage_1.Storage.createObject('index://range', {
-    timestamp: 'number',
+    timestamp: 'bigint',
     uri: 'string',
-    min: 'number',
-    max: 'number'
+    min: 'bigint',
+    max: 'bigint'
 });
 function useReplayStorage(uri, { sync }) {
     const { watch } = (0, use_replay_scheduler_1.useReplayScheduler)();
-    const { info } = (0, use_logger_1.useLogger)(useReplayStorage.name);
+    const { info, error } = (0, use_logger_1.useLogger)(useReplayStorage.name);
     const options = (0, use_replay_options_1.useReplayOptions)();
     const storage = (0, storage_1.useStorage)([options.storage]);
     const storageObjectKey = uri.query;
     const storageObject = storage_1.Storage.createObject(storageObjectKey, {
-        timestamp: 'number',
+        timestamp: 'bigint',
         payload: 'string'
     });
-    const id = (0, hash_code_1.hashCode)(storageObjectKey);
+    const id = (0, use_timestamp_1.ns)((0, hash_code_1.hashCode)(storageObjectKey));
     return {
         watch: () => (0, use_memo_1.useMemo)(() => watch({
-            query(query) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    const [index] = yield storage.query(storageIndexObject, {
-                        limit: 1,
-                        where: { timestamp: (0, storage_1.eq)(id) }
-                    });
-                    const { min, max } = query.where.timestamp;
-                    if (!index || min < index.min || max > index.max) {
-                        info(`fetching replay for ${storageObjectKey} started`);
-                        yield sync(query, {
-                            save(objects) {
-                                return __awaiter(this, void 0, void 0, function* () {
-                                    yield storage.save(storageObject, objects.map(it => ({
-                                        timestamp: it.timestamp,
-                                        payload: JSON.stringify(it.payload)
-                                    })));
-                                });
+            async query(query) {
+                const [index] = await storage.query(storageIndexObject, {
+                    limit: 1,
+                    where: { timestamp: (0, storage_1.eq)(id) }
+                });
+                const { min, max } = query.where.timestamp;
+                if (!index || min < index.min || max > index.max) {
+                    info(`fetching replay for ${storageObjectKey} started`);
+                    try {
+                        await sync(query, {
+                            async save(objects) {
+                                await storage.save(storageObject, objects.map(it => ({
+                                    timestamp: it.timestamp,
+                                    payload: JSON.stringify(it.payload)
+                                })));
                             }
                         });
-                        yield storage.save(storageIndexObject, [
+                        await storage.save(storageIndexObject, [
                             {
                                 timestamp: id,
                                 max,
@@ -63,13 +53,16 @@ function useReplayStorage(uri, { sync }) {
                                 uri: storageObjectKey
                             }
                         ]);
-                        info(`fetching replay for ${storageObjectKey} finished`);
                     }
-                    return (yield storage.query(storageObject, query)).map(it => ({
-                        timestamp: it.timestamp,
-                        payload: JSON.parse(it.payload)
-                    }));
-                });
+                    catch (err) {
+                        error(`fetching replay for ${storageObjectKey} failed: ${err}`);
+                    }
+                    info(`fetching replay for ${storageObjectKey} finished`);
+                }
+                return (await storage.query(storageObject, query)).map(it => ({
+                    timestamp: it.timestamp,
+                    payload: JSON.parse(it.payload)
+                }));
             }
         }).pipe((0, rxjs_1.share)()), [useReplayStorage.name, storageObjectKey])
     };

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

@@ -1,2 +1,2 @@
-export declare const useSessionStorage: () => import("../storage").Storage;
+export declare function useSessionStorage(): import("../storage").Storage;
 //# sourceMappingURL=use-session-storage.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"use-session-storage.d.ts","sourceRoot":"","sources":["../../src/session/use-session-storage.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,iBAAiB,sCAI5B,CAAC"}
+{"version":3,"file":"use-session-storage.d.ts","sourceRoot":"","sources":["../../src/session/use-session-storage.ts"],"names":[],"mappings":"AAIA,wBAAgB,iBAAiB,mCAMhC"}

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

@@ -3,8 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useSessionStorage = void 0;
 const session_1 = require("../session");
 const storage_1 = require("../storage");
-const with_memo_1 = require("../with-memo");
-exports.useSessionStorage = (0, with_memo_1.withMemo)(() => {
-    const { id } = (0, session_1.useSession)();
-    return (0, storage_1.useStorage)(['session', id]);
-});
+const use_memo_1 = require("../use-memo");
+function useSessionStorage() {
+    return (0, use_memo_1.useMemo)(() => {
+        const { id } = (0, session_1.useSession)();
+        return (0, storage_1.useStorage)(['session', id]);
+    }, [useSessionStorage.name]);
+}
+exports.useSessionStorage = useSessionStorage;

package/lib/shared/environment.js

@@ -10,6 +10,6 @@ function getEnvVar(name, optional = false) {
     if (!value && !optional) {
         throw new Error(`Missing environment variable: ${name}`);
     }
-    return value !== null && value !== void 0 ? value : '';
+    return value ?? '';
 }
 exports.getEnvVar = getEnvVar;

package/lib/shared/index.d.ts

@@ -1,4 +1,3 @@
-export * from '../shared/datetime';
 export * from '../shared/decimals';
 export * from '../shared/environment';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/shared/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/shared/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC"}

package/lib/shared/index.js

@@ -14,6 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("../shared/datetime"), exports);
 __exportStar(require("../shared/decimals"), exports);
 __exportStar(require("../shared/environment"), exports);