@quantform/core 0.6.7 → 0.7.0-beta.5

package/dist/make-test-module.js

@@ -0,0 +1,46 @@
+"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.toArray = exports.mockedFunc = exports.makeTestModule = void 0;
+const rxjs_1 = require("rxjs");
+const core_1 = require("./core");
+const module_1 = require("./module");
+function makeTestModule(dependencies) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const module = new module_1.Module([...(0, core_1.core)(), ...dependencies]);
+        const { act } = yield module.awake();
+        return {
+            act,
+            get: module.get.bind(module)
+        };
+    });
+}
+exports.makeTestModule = makeTestModule;
+const mockedFunc = (mockedFunc) => mockedFunc;
+exports.mockedFunc = mockedFunc;
+function toArray(observable) {
+    const array = Array.of();
+    const clone = (it) => {
+        if (typeof it === 'symbol') {
+            return it;
+        }
+        if (Array.isArray(it)) {
+            return it.map(it => clone(it));
+        }
+        if (typeof it === 'object') {
+            return Object.assign({}, it);
+        }
+        return it;
+    };
+    observable.pipe((0, rxjs_1.tap)(it => array.push(clone(it)))).subscribe();
+    return array;
+}
+exports.toArray = toArray;

package/dist/module.d.ts

@@ -0,0 +1,57 @@
+import 'reflect-metadata';
+import { DependencyContainer, inject, injectable, injectAll, InjectionToken } from 'tsyringe';
+export declare const provider: typeof injectable;
+export declare const provide: typeof inject;
+export declare const provideAll: typeof injectAll;
+export type Dependency = {
+    provide: InjectionToken;
+    useClass?: any;
+    useValue?: any;
+};
+/**
+ * Hook to get access to current execution module dependencies.
+ */
+export declare const useContext: <T>(token: InjectionToken<T>) => T;
+/**
+ * Hook to get access to current execution module dependencies.
+ */
+export declare const throwWithContext: () => void;
+/**
+ * A module is a collection of services, values, and factories that can be
+ * registered with a dependency container.
+ */
+export declare class Module {
+    private readonly dependencies;
+    private container?;
+    constructor(dependencies: Dependency[]);
+    /**
+     * Builds and initializes dependencies.
+     */
+    awake(): Promise<{
+        act: <T>(func: () => T) => T;
+    }>;
+    /**
+     * Disposes all dependencies instantiated by this module.
+     * @returns
+     */
+    dispose(): void;
+    /**
+     * Builds a new instance of dependency container based on module definition.
+     * @returns
+     */
+    protected buildContainer(): DependencyContainer;
+    /**
+     * Resolves a dependency from the module.
+     * @param token represents the identifier for the dependency that you want to
+     * resolve from the container.
+     * @returns instance of the dependency.
+     */
+    get<T>(token: InjectionToken<T>): T;
+    /**
+     * Resolves a collection of dependencies from the module.
+     * @param token
+     * @returns
+     */
+    getAll<T>(token: InjectionToken<T>): T[];
+}
+//# sourceMappingURL=module.d.ts.map

package/dist/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,oCAQtB,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/dist/module.js

@@ -0,0 +1,136 @@
+"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.Module = exports.throwWithContext = exports.useContext = exports.provideAll = exports.provide = exports.provider = void 0;
+require("reflect-metadata");
+const node_async_hooks_1 = require("node:async_hooks");
+const tsyringe_1 = require("tsyringe");
+exports.provider = tsyringe_1.injectable;
+exports.provide = tsyringe_1.inject;
+exports.provideAll = tsyringe_1.injectAll;
+function noModuleError() {
+    return new Error('Please do not use dependency injection outside of hooks context.');
+}
+function withModuleError() {
+    return new Error('Please do not use with hooks in context.');
+}
+function notInitializedModuleError() {
+    return new Error('You need to initialize a module before use.');
+}
+function missingInjectionTokenError(token) {
+    return new Error(`Unable to resolve unregistered dependency: ${token.toString()}`);
+}
+/**
+ *
+ */
+const moduleLocalStorage = new node_async_hooks_1.AsyncLocalStorage();
+/**
+ * Hook to get access to current execution module dependencies.
+ */
+const useContext = (token) => {
+    const module = moduleLocalStorage.getStore();
+    if (!module) {
+        throw noModuleError();
+    }
+    return module.get(token);
+};
+exports.useContext = useContext;
+/**
+ * Hook to get access to current execution module dependencies.
+ */
+const throwWithContext = () => {
+    if (moduleLocalStorage.getStore()) {
+        throw withModuleError();
+    }
+};
+exports.throwWithContext = throwWithContext;
+/**
+ * A module is a collection of services, values, and factories that can be
+ * registered with a dependency container.
+ */
+class Module {
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    /**
+     * Builds and initializes dependencies.
+     */
+    awake() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.container = this.buildContainer();
+            return {
+                /**
+                 * Associate callback function with current executing module
+                 */
+                act: (func) => moduleLocalStorage.run(this, func)
+            };
+        });
+    }
+    /**
+     * Disposes all dependencies instantiated by this module.
+     * @returns
+     */
+    dispose() {
+        if (!this.container) {
+            return;
+        }
+        this.container = undefined;
+    }
+    /**
+     * Builds a new instance of dependency container based on module definition.
+     * @returns
+     */
+    buildContainer() {
+        const childContainer = tsyringe_1.container.createChildContainer();
+        this.dependencies.forEach(it => {
+            var _a;
+            if (it.useValue) {
+                childContainer.register(it.provide, { useValue: it.useValue });
+            }
+            else {
+                childContainer.register(it.provide, (_a = it.useClass) !== null && _a !== void 0 ? _a : it.provide, {
+                    lifecycle: tsyringe_1.Lifecycle.Singleton
+                });
+            }
+        });
+        return childContainer;
+    }
+    /**
+     * Resolves a dependency from the module.
+     * @param token represents the identifier for the dependency that you want to
+     * resolve from the container.
+     * @returns instance of the dependency.
+     */
+    get(token) {
+        if (!this.container) {
+            throw notInitializedModuleError();
+        }
+        if (!this.container.isRegistered(token)) {
+            throw missingInjectionTokenError(token);
+        }
+        return this.container.resolve(token);
+    }
+    /**
+     * Resolves a collection of dependencies from the module.
+     * @param token
+     * @returns
+     */
+    getAll(token) {
+        if (!this.container) {
+            throw notInitializedModuleError();
+        }
+        if (!this.container.isRegistered(token)) {
+            throw missingInjectionTokenError(token);
+        }
+        return tsyringe_1.container.resolveAll(token);
+    }
+}
+exports.Module = Module;

package/dist/module.spec.d.ts

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

package/dist/module.spec.d.ts.map

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

package/dist/module.spec.js

@@ -0,0 +1,86 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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 module_1 = require("./module");
+describe(module_1.Module.name, () => {
+    let fixtures;
+    beforeEach(() => {
+        fixtures = getFixtures();
+    });
+    test('builds empty module', () => __awaiter(void 0, void 0, void 0, function* () {
+        const module = fixtures.givenModuleCreated([]);
+        fixtures.whenModuleBuilt(module);
+    }));
+    test('builds module and resolves single value dependency', () => __awaiter(void 0, void 0, void 0, function* () {
+        const definition = fixtures.definitions.singleValue;
+        const module = fixtures.givenModuleCreated(definition);
+        fixtures.whenModuleBuilt(module);
+        fixtures.thenCanResolveDependencies(module, definition);
+    }));
+    test('builds module and resolves single class dependency', () => __awaiter(void 0, void 0, void 0, function* () {
+        const definition = fixtures.definitions.singleClass;
+        const module = fixtures.givenModuleCreated(definition);
+        fixtures.whenModuleBuilt(module);
+        fixtures.thenCanResolveDependencies(module, definition);
+    }));
+    test('builds module and resolves many class dependencies', () => __awaiter(void 0, void 0, void 0, function* () {
+        const definition = fixtures.definitions.manyClass;
+        const module = fixtures.givenModuleCreated(definition);
+        fixtures.whenModuleBuilt(module);
+        fixtures.thenCanResolveDependencies(module, definition);
+    }));
+});
+function getFixtures() {
+    return {
+        definitions: {
+            singleClass: [
+                {
+                    provide: FakeService,
+                    useClass: FakeService
+                }
+            ],
+            manyClass: [
+                {
+                    provide: FakeService,
+                    useClass: FakeService
+                },
+                {
+                    provide: FakeService,
+                    useClass: FakeService
+                }
+            ],
+            singleValue: [
+                {
+                    provide: FakeService,
+                    useValue: new FakeService()
+                }
+            ]
+        },
+        givenModuleCreated: (dependencies) => new module_1.Module(dependencies),
+        whenModuleBuilt: (module) => module.awake(),
+        thenCanResolveDependencies: (module, dependencies) => {
+            dependencies.forEach(it => {
+                expect(module.get(it.provide)).toBeTruthy();
+            });
+        }
+    };
+}
+let FakeService = class FakeService {
+};
+FakeService = __decorate([
+    (0, module_1.provider)()
+], FakeService);

package/dist/not-found.d.ts

@@ -0,0 +1,2 @@
+export declare const notFound: unique symbol;
+//# sourceMappingURL=not-found.d.ts.map

package/dist/not-found.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-found.d.ts","sourceRoot":"","sources":["../src/not-found.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,eAA0B,CAAC"}

package/dist/{domain/component.js → not-found.js}

@@ -1,2 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.notFound = void 0;
+exports.notFound = Symbol.for('not-found');

package/dist/replay/index.d.ts

@@ -0,0 +1,7 @@
+export * from './use-replay';
+export * from './use-replay-coordinator';
+export * from './use-replay-options';
+export * from './use-replay-reader';
+export * from './use-replay-writer';
+export * from './with-replay';
+//# sourceMappingURL=index.d.ts.map

package/dist/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,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC"}

package/dist/replay/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./use-replay"), exports);
+__exportStar(require("./use-replay-coordinator"), exports);
+__exportStar(require("./use-replay-options"), exports);
+__exportStar(require("./use-replay-reader"), exports);
+__exportStar(require("./use-replay-writer"), exports);
+__exportStar(require("./with-replay"), exports);

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,119 @@
+"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-options.d.ts

@@ -0,0 +1,15 @@
+import { Dependency } from '../module';
+type ReplayOptions = {
+    from: number;
+    to: number;
+};
+/**
+ *
+ */
+export declare function replayOptions(options: ReplayOptions): Dependency;
+/**
+ * Will return current replay execution options.
+ */
+export declare const useReplayOptions: () => ReplayOptions;
+export {};
+//# sourceMappingURL=use-replay-options.d.ts.map

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

@@ -0,0 +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;CACZ,CAAC;AAEF;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,UAAU,CAKhE;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,qBAAkD,CAAC"}

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

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

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,32 @@
+"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

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

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

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