@quantform/core 0.7.0-beta.5 → 0.7.0-beta.51

package/lib/shared/decimals.d.ts

@@ -0,0 +1,14 @@
+import { Decimal } from 'decimal.js';
+declare module 'decimal.js' {
+    interface Decimal {
+        toFloor(decimalPlaces: number): Decimal;
+        toCeil(decimalPlaces: number): Decimal;
+    }
+}
+export declare class decimal extends Decimal {
+}
+export declare function d(value: Decimal.Value): decimal;
+export declare namespace d {
+    var Zero: decimal;
+}
+//# sourceMappingURL=decimals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decimals.d.ts","sourceRoot":"","sources":["../../src/shared/decimals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC,OAAO,QAAQ,YAAY,CAAC;IAC1B,UAAU,OAAO;QACf,OAAO,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC;QACxC,MAAM,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC;KACxC;CACF;AAUD,qBAAa,OAAQ,SAAQ,OAAO;CAAG;AAEvC,wBAAgB,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,WAErC;yBAFe,CAAC"}

package/lib/shared/decimals.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.d = exports.decimal = void 0;
+const decimal_js_1 = require("decimal.js");
+decimal_js_1.Decimal.prototype.toFloor = function (decimalPlaces) {
+    return this.toDecimalPlaces(decimalPlaces, decimal_js_1.Decimal.ROUND_FLOOR);
+};
+decimal_js_1.Decimal.prototype.toCeil = function (decimalPlaces) {
+    return this.toDecimalPlaces(decimalPlaces, decimal_js_1.Decimal.ROUND_CEIL);
+};
+class decimal extends decimal_js_1.Decimal {
+}
+exports.decimal = decimal;
+function d(value) {
+    return new decimal(value);
+}
+exports.d = d;
+d.Zero = new decimal(0);

package/{dist → lib}/simulator/use-simulator.spec.js

@@ -12,38 +12,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const make_test_module_1 = require("../make-test-module");
 const use_execution_mode_1 = require("../use-execution-mode");
 const use_simulator_1 = require("./use-simulator");
-jest.mock('@lib/use-execution-mode', () => (Object.assign(Object.assign({}, jest.requireActual('@lib/use-execution-mode')), { useExecutionMode: jest.fn() })));
 describe(use_simulator_1.useSimulator.name, () => {
     let fixtures;
     beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
         fixtures = yield getFixtures();
     }));
-    afterEach(() => fixtures.clear());
-    test('get real value when simulator mode disabled', () => {
-        const { act } = fixtures;
-        fixtures.givenSimulationEnabled(false);
+    test('get real value when simulator mode disabled', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { act } = yield fixtures.givenModule(false);
         const value = act(() => (0, use_simulator_1.useSimulator)('simulator', 'real'));
         expect(value).toBe('real');
-    });
-    test('get simulation value when simulator mode enabled', () => {
-        const { act } = fixtures;
-        fixtures.givenSimulationEnabled(true);
+    }));
+    test('get simulation value when simulator mode enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { act } = yield fixtures.givenModule(true);
         const value = act(() => (0, use_simulator_1.useSimulator)('simulator', 'real'));
         expect(value).toBe('simulator');
-    });
+    }));
 });
 function getFixtures() {
     return __awaiter(this, void 0, void 0, function* () {
-        const { act } = yield (0, make_test_module_1.makeTestModule)([]);
         return {
-            act,
-            givenSimulationEnabled(isSimulation) {
-                (0, make_test_module_1.mockedFunc)(use_execution_mode_1.useExecutionMode).mockReturnValue({
-                    isSimulation,
-                    recording: false
+            givenModule(isSimulation) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return isSimulation
+                        ? yield (0, make_test_module_1.makeTestModule)([use_execution_mode_1.useExecutionMode.paperOptions({ recording: false })])
+                        : yield (0, make_test_module_1.makeTestModule)([use_execution_mode_1.useExecutionMode.liveOptions({ recording: false })]);
                 });
-            },
-            clear: jest.clearAllMocks
+            }
         };
     });
 }

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC"}

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

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./storage"), exports);
+__exportStar(require("./use-cache"), exports);
 __exportStar(require("./use-storage"), exports);
 __exportStar(require("./use-storage-factory"), exports);
 __exportStar(require("./in-memory"), exports);

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

@@ -0,0 +1,10 @@
+import { Dependency } from '../module';
+import { Storage } from '../storage';
+export interface StorageFactory {
+    for(key: string): Storage;
+}
+export declare function useStorageFactory(): StorageFactory;
+export declare namespace useStorageFactory {
+    var options: (factory: StorageFactory) => Dependency;
+}
+//# sourceMappingURL=use-storage-factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-storage-factory.d.ts","sourceRoot":"","sources":["../../src/storage/use-storage-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAc,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAED,wBAAgB,iBAAiB,mBAEhC;yBAFe,iBAAiB"}

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStorageFactory = void 0;
+const module_1 = require("../module");
+const token = Symbol('storage-factory-token');
+function useStorageFactory() {
+    return (0, module_1.useContext)(token);
+}
+exports.useStorageFactory = useStorageFactory;
+useStorageFactory.options = (factory) => ({
+    provide: token,
+    useValue: factory
+});

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-storage.d.ts","sourceRoot":"","sources":["../../src/storage/use-storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAKpD,eAAO,MAAM,UAAU,6DAKrB,CAAC"}

package/{dist → lib}/storage/use-storage.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useStorage = void 0;
-const use_1 = require("../use");
 const use_hash_1 = require("../use-hash");
+const with_memo_1 = require("../with-memo");
 const use_storage_factory_1 = require("./use-storage-factory");
-exports.useStorage = (0, use_1.use)((dependencies) => {
+exports.useStorage = (0, with_memo_1.withMemo)((dependencies) => {
     const key = (0, use_hash_1.useHash)(dependencies);
     const factory = (0, use_storage_factory_1.useStorageFactory)();
     return factory.for(key);

package/lib/strategy.d.ts

@@ -0,0 +1,15 @@
+import { Observable } from 'rxjs';
+import { Dependency } from './module';
+export type Descriptor = () => Observable<unknown>;
+export declare let before: (descriptor: Descriptor) => void;
+export declare let behavior: (descriptor: Descriptor) => void;
+export declare let after: (descriptor: Descriptor) => void;
+export declare function strategy(descriptor: () => Dependency[]): {
+    dependencies: Dependency[];
+    description: {
+        before: Descriptor[];
+        behavior: Descriptor[];
+        after: Descriptor[];
+    };
+};
+//# sourceMappingURL=strategy.d.ts.map

package/lib/strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../src/strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAM,MAAM,MAAM,CAAC;AAEtC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC,MAAM,MAAM,UAAU,GAAG,MAAM,UAAU,CAAC,OAAO,CAAC,CAAC;AAEnD,eAAO,IAAI,MAAM,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,CAAC;AACpD,eAAO,IAAI,QAAQ,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,CAAC;AACtD,eAAO,IAAI,KAAK,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,CAAC;AAEnD,wBAAgB,QAAQ,CAAC,UAAU,EAAE,MAAM,UAAU,EAAE;;;;;;;EAyBtD"}

package/lib/strategy.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strategy = exports.after = exports.behavior = exports.before = void 0;
+const rxjs_1 = require("rxjs");
+function strategy(descriptor) {
+    const description = {
+        before: Array.of(),
+        behavior: Array.of(),
+        after: Array.of()
+    };
+    exports.before = descriptor => description.before.push(descriptor);
+    exports.behavior = descriptor => description.behavior.push(descriptor);
+    exports.after = descriptor => description.after.push(descriptor);
+    const dependencies = descriptor();
+    if (!description.before.length) {
+        description.before.push(() => (0, rxjs_1.of)(true));
+    }
+    if (!description.after.length) {
+        description.after.push(() => (0, rxjs_1.of)(true));
+    }
+    return {
+        dependencies,
+        description
+    };
+}
+exports.strategy = strategy;

package/lib/strategy.spec.d.ts

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

package/lib/strategy.spec.d.ts.map

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

package/lib/strategy.spec.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rxjs_1 = require("rxjs");
+const strategy_1 = require("./strategy");
+describe(strategy_1.strategy.name, () => {
+    let fixtures;
+    beforeEach(() => {
+        fixtures = getFixtures();
+    });
+    test('happy path', () => {
+        const sut = (0, strategy_1.strategy)(() => {
+            (0, strategy_1.before)(() => (0, rxjs_1.of)('before'));
+            (0, strategy_1.behavior)(() => (0, rxjs_1.of)('behavior 1'));
+            (0, strategy_1.behavior)(() => (0, rxjs_1.of)('behavior 2'));
+            (0, strategy_1.after)(() => (0, rxjs_1.of)('after'));
+            return fixtures.given.dependencies();
+        });
+        expect(sut.dependencies).toEqual(expect.arrayContaining(fixtures.given.dependencies()));
+        expect(sut.description).toEqual({
+            before: [expect.any(Function)],
+            behavior: [expect.any(Function), expect.any(Function)],
+            after: [expect.any(Function)]
+        });
+    });
+});
+function getFixtures() {
+    return {
+        given: {
+            dependencies() {
+                return [];
+            }
+        }
+    };
+}

package/lib/use-execution-mode.d.ts

@@ -0,0 +1,20 @@
+import { Dependency } from './module';
+export declare function useExecutionMode(): {
+    isReplay: boolean;
+    isPaper: boolean;
+    isLive: boolean;
+    isIdle: boolean;
+    isSimulation: boolean;
+    recording: boolean;
+};
+export declare namespace useExecutionMode {
+    var replayOptions: () => Dependency;
+    var paperOptions: (options: {
+        recording: boolean;
+    }) => Dependency;
+    var liveOptions: (options: {
+        recording: boolean;
+    }) => Dependency;
+    var idleOptions: () => Dependency;
+}
+//# sourceMappingURL=use-execution-mode.d.ts.map

package/lib/use-execution-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-execution-mode.d.ts","sourceRoot":"","sources":["../src/use-execution-mode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAc,MAAM,aAAa,CAAC;AASrD,wBAAgB,gBAAgB;;;;;;;EAW/B;yBAXe,gBAAgB"}

package/lib/use-execution-mode.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useExecutionMode = void 0;
+const module_1 = require("./module");
+const injectionToken = Symbol('execution-mode');
+function useExecutionMode() {
+    const { mode, recording } = (0, module_1.useContext)(injectionToken);
+    return {
+        isReplay: mode === 'replay',
+        isPaper: mode === 'paper',
+        isLive: mode === 'live',
+        isIdle: mode === 'idle',
+        isSimulation: mode !== 'live',
+        recording
+    };
+}
+exports.useExecutionMode = useExecutionMode;
+useExecutionMode.replayOptions = () => ({
+    provide: injectionToken,
+    useValue: { mode: 'replay', recording: false }
+});
+useExecutionMode.paperOptions = (options) => ({
+    provide: injectionToken,
+    useValue: Object.assign({ mode: 'paper' }, options)
+});
+useExecutionMode.liveOptions = (options) => ({
+    provide: injectionToken,
+    useValue: Object.assign({ mode: 'live' }, options)
+});
+useExecutionMode.idleOptions = () => ({
+    provide: injectionToken,
+    useValue: { mode: 'idle', recording: false }
+});

package/{dist → lib}/use-logger.js

@@ -5,8 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useLogger = void 0;
 const chalk_1 = __importDefault(require("chalk"));
-const use_1 = require("./use");
 const use_timestamp_1 = require("./use-timestamp");
+const with_memo_1 = require("./with-memo");
 const colorize = (content) => {
     let hash = 0x811c9dc5;
     for (let i = 0; i < content.length; i++) {
@@ -18,8 +18,8 @@ const colorize = (content) => {
 /**
  *
  */
-exports.useLogger = (0, use_1.use)((context, tint) => {
-    const prefix = () => `${chalk_1.default.gray(new Date((0, use_timestamp_1.useTimestamp)()).toISOString())} ${chalk_1.default.hex(tint !== null && tint !== void 0 ? tint : colorize(context))(context)}`;
+exports.useLogger = (0, with_memo_1.withMemo)((context, tint) => {
+    const prefix = () => `${chalk_1.default.hex(tint !== null && tint !== void 0 ? tint : colorize(context))(new Date((0, use_timestamp_1.useTimestamp)()).toISOString())} ${chalk_1.default.hex(tint !== null && tint !== void 0 ? tint : colorize(context))(context)}`;
     return {
         info: (message, ...params) => (params === null || params === void 0 ? void 0 : params.length)
             ? console.info(`${prefix()}: ${message}`, params)
@@ -31,7 +31,7 @@ exports.useLogger = (0, use_1.use)((context, tint) => {
             ? console.warn(`${prefix()}: ${message}`, params)
             : console.warn(`${prefix()}: ${message}`),
         error: (message, ...params) => (params === null || params === void 0 ? void 0 : params.length)
-            ? console.error(`${prefix()}: ${message}`, params)
-            : console.error(`${prefix()}: ${message}`)
+            ? console.error(`${prefix()}: ${chalk_1.default.red(message)}`, params)
+            : console.error(`${prefix()}: ${chalk_1.default.red(message)}`)
     };
 });

package/lib/use-memo.d.ts

@@ -0,0 +1,8 @@
+import { Dependency } from './module';
+import { dependency } from './use-hash';
+export declare const token: unique symbol;
+export declare function useMemo<T>(calculateValue: () => T, dependencies: dependency[]): T;
+export declare namespace useMemo {
+    var options: () => Dependency;
+}
+//# sourceMappingURL=use-memo.d.ts.map

package/lib/use-memo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-memo.d.ts","sourceRoot":"","sources":["../src/use-memo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAc,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAEpD,eAAO,MAAM,KAAK,eAAuB,CAAC;AAE1C,wBAAgB,OAAO,CAAC,CAAC,EAAE,cAAc,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,UAAU,EAAE,KAS7E;yBATe,OAAO"}

package/lib/use-memo.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMemo = exports.token = void 0;
+const module_1 = require("./module");
+const use_hash_1 = require("./use-hash");
+exports.token = Symbol('memo-token');
+function useMemo(calculateValue, dependencies) {
+    const memory = (0, module_1.useContext)(exports.token);
+    const hash = (0, use_hash_1.useHash)(dependencies);
+    if (memory[hash]) {
+        return memory[hash];
+    }
+    return (memory[hash] = calculateValue());
+}
+exports.useMemo = useMemo;
+useMemo.options = () => ({
+    provide: exports.token,
+    useValue: {}
+});

package/lib/use-socket.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+export declare function useSocket(url: string, options?: {
+    pingInterval?: number;
+}): {
+    /**
+     * Observes socket events and handles connection health monitoring via ping/pong
+     * @returns observable emitting message events with timestamps and parsed payloads
+     */
+    watch(): Observable<{
+        timestamp: number;
+        payload: unknown;
+    }>;
+    send(message: {
+        payload: unknown;
+    }): Observable<{
+        timestamp: number;
+    }>;
+    monitor(): Observable<"opened" | "closed" | "errored">;
+};
+//# sourceMappingURL=use-socket.d.ts.map

package/lib/use-socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-socket.d.ts","sourceRoot":"","sources":["../src/use-socket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,UAAU,EAAqB,MAAM,MAAM,CAAC;AAM5D,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAA2B;IAsBzD;;;OAGG;aACM,WAAW;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;kBAgD9C;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,WAAW;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;;EAczE"}

package/lib/use-socket.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSocket = void 0;
+const rxjs_1 = require("rxjs");
+const ws_1 = require("ws");
+const use_logger_1 = require("./use-logger");
+const use_timestamp_1 = require("./use-timestamp");
+function useSocket(url, options = { pingInterval: 5000 }) {
+    const { debug } = (0, use_logger_1.useLogger)('useSocket');
+    const socket = new ws_1.WebSocket(url);
+    const monitor = new rxjs_1.ReplaySubject();
+    socket.on('error', e => {
+        debug('errored', url, e);
+        monitor.next('errored');
+    });
+    socket.on('close', () => {
+        debug('closed', url);
+        monitor.next('closed');
+    });
+    socket.on('open', () => {
+        debug('opened', url);
+        monitor.next('opened');
+    });
+    return {
+        /**
+         * Observes socket events and handles connection health monitoring via ping/pong
+         * @returns observable emitting message events with timestamps and parsed payloads
+         */
+        watch() {
+            let isAlive = false;
+            let interval;
+            return new rxjs_1.Observable(stream => {
+                socket.onmessage = it => stream.next({
+                    timestamp: (0, use_timestamp_1.useTimestamp)(),
+                    payload: JSON.parse(it.data)
+                });
+                socket.onerror = it => {
+                    clearInterval(interval);
+                    stream.error(it);
+                };
+                socket.onclose = () => {
+                    clearInterval(interval);
+                    stream.error();
+                };
+                socket.onopen = () => {
+                    isAlive = true;
+                    interval = setInterval(() => {
+                        if (isAlive) {
+                            isAlive = false;
+                            socket.ping();
+                        }
+                        else {
+                            socket.terminate();
+                            clearInterval(interval);
+                        }
+                    }, options.pingInterval);
+                    socket.on('pong', () => {
+                        isAlive = true;
+                    });
+                    socket.on('ping', () => {
+                        isAlive = true;
+                        socket.pong();
+                    });
+                };
+                return () => {
+                    clearInterval(interval);
+                    socket.terminate();
+                };
+            });
+        },
+        send(message) {
+            return (0, rxjs_1.defer)(() => {
+                debug('sent', url, message.payload);
+                socket.send(JSON.stringify(message.payload));
+                return (0, rxjs_1.of)({ timestamp: (0, use_timestamp_1.useTimestamp)() });
+            });
+        },
+        monitor() {
+            return monitor.asObservable();
+        }
+    };
+}
+exports.useSocket = useSocket;

package/{dist → lib}/use-timestamp.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useTimestamp = void 0;
-const use_replay_coordinator_1 = require("./replay/use-replay-coordinator");
+const replay_1 = require("./replay");
 const use_execution_mode_1 = require("./use-execution-mode");
 function useTimestamp() {
     const { isReplay } = (0, use_execution_mode_1.useExecutionMode)();
     if (isReplay) {
-        return (0, use_replay_coordinator_1.useReplayCoordinator)().timestamp();
+        return (0, replay_1.useReplayManager)().timestamp();
     }
     return Date.now();
 }

package/lib/when-socket.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+export declare function whenSocket(url: string, options?: {
+    pingInterval?: number;
+}): [Observable<{
+    timestamp: number;
+    payload: unknown;
+}>, (message: unknown) => void];
+//# sourceMappingURL=when-socket.d.ts.map

package/lib/when-socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"when-socket.d.ts","sourceRoot":"","sources":["../src/when-socket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAMlC,wBAAgB,UAAU,CACxB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAA2B,GAC1D,CAAC,UAAU,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,CAmDnF"}

package/{dist/use-socket.js → lib/when-socket.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useSocket = void 0;
+exports.whenSocket = void 0;
 const rxjs_1 = require("rxjs");
 const ws_1 = require("ws");
 const use_logger_1 = require("./use-logger");
 const use_timestamp_1 = require("./use-timestamp");
-function useSocket(url) {
-    const { debug } = (0, use_logger_1.useLogger)('useSocket');
+function whenSocket(url, options = { pingInterval: 5000 }) {
+    const { debug } = (0, use_logger_1.useLogger)('whenSocket');
     const message = new rxjs_1.Observable(stream => {
         const socket = new ws_1.WebSocket(url);
         let isAlive = false;
@@ -14,6 +14,7 @@ function useSocket(url) {
         socket.onmessage = it => stream.next({ timestamp: (0, use_timestamp_1.useTimestamp)(), payload: JSON.parse(it.data) });
         socket.onerror = it => {
             clearInterval(interval);
+            debug('errored', url);
             stream.error(it);
         };
         socket.onclose = () => {
@@ -33,7 +34,7 @@ function useSocket(url) {
                     socket.terminate();
                     clearInterval(interval);
                 }
-            }, 5000);
+            }, options.pingInterval);
             socket.on('pong', () => {
                 isAlive = true;
             });
@@ -49,4 +50,4 @@ function useSocket(url) {
     });
     return [message, (message) => JSON.stringify(message)];
 }
-exports.useSocket = useSocket;
+exports.whenSocket = whenSocket;

package/lib/with-memo.d.ts

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

package/lib/with-memo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-memo.d.ts","sourceRoot":"","sources":["../src/with-memo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,UAAU,EAAe,MAAM,MAAM,CAAC;AAK7D,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGxC,wBAAgB,QAAQ,CAAC,CAAC,SAAS,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC,EACrD,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,GACpB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;AACrB,wBAAgB,QAAQ,CAAC,CAAC,SAAS,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC,EACrD,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,GAChC,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC"}

package/{dist/use.js → lib/with-memo.js}

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.use = void 0;
+exports.withMemo = void 0;
 const rxjs_1 = require("rxjs");
 const uuid_1 = require("uuid");
-const as_readonly_1 = require("./as-readonly");
 const module_1 = require("./module");
+const operators_1 = require("./operators");
 const use_memo_1 = require("./use-memo");
-function use(fn) {
+function withMemo(fn) {
     (0, module_1.throwWithContext)();
     const uniqueId = (0, uuid_1.v4)();
     return (...args) => (0, use_memo_1.useMemo)(() => {
         const value = fn(...args);
         if ((0, rxjs_1.isObservable)(value)) {
-            return value.pipe((0, as_readonly_1.asReadonly)(), (0, rxjs_1.shareReplay)(1));
+            return value.pipe((0, operators_1.asReadonly)(), (0, rxjs_1.shareReplay)(1));
         }
         return value;
     }, [uniqueId, ...args]);
 }
-exports.use = use;
+exports.withMemo = withMemo;

package/lib/with-memo.spec.d.ts

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

package/lib/with-memo.spec.d.ts.map

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

package/{dist/use.spec.js → lib/with-memo.spec.js}

@@ -11,8 +11,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 const make_test_module_1 = require("./make-test-module");
 const instrument_1 = require("./instrument");
-const use_1 = require("./use");
-describe(use_1.use.name, () => {
+const with_memo_1 = require("./with-memo");
+describe(with_memo_1.withMemo.name, () => {
     let fixtures;
     beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
         fixtures = yield getFixtures();
@@ -38,7 +38,7 @@ describe(use_1.use.name, () => {
 function getFixtures() {
     return __awaiter(this, void 0, void 0, function* () {
         const { act } = yield (0, make_test_module_1.makeTestModule)([]);
-        const getValue = (0, use_1.use)((instrument) => instrument.id);
+        const getValue = (0, with_memo_1.withMemo)((instrument) => instrument.id);
         return {
             act,
             getValue: act(() => (instrument) => getValue(instrument))

package/{dist/use-request.d.ts → lib/with-request.d.ts}

@@ -1,16 +1,16 @@
+import { Observable } from 'rxjs';
 export type RequestMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH';
 export declare class RequestNetworkError extends Error {
     readonly statusCode: number;
-    readonly json: () => Promise<string>;
-    constructor(statusCode: number, json: () => Promise<string>);
+    constructor(statusCode: number);
 }
-export declare function useRequest(args: {
+export declare function withRequest({ method, url, headers, body }: {
     method: RequestMethod;
     url: string;
     headers?: Record<string, any>;
     body?: string;
-}): import("rxjs").Observable<{
+}): Observable<{
     timestamp: number;
-    payload: any;
+    payload: unknown;
 }>;
-//# sourceMappingURL=use-request.d.ts.map
+//# sourceMappingURL=with-request.d.ts.map