@quantform/core 0.6.7 → 0.7.0-beta.5

package/dist/storage/use-cache.spec.js

@@ -0,0 +1,36 @@
+"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 rxjs_1 = require("rxjs");
+const make_test_module_1 = require("../make-test-module");
+const use_cache_1 = require("../storage/use-cache");
+describe(use_cache_1.useCache.name, () => {
+    let fixtures;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        fixtures = yield getFixtures();
+    }));
+    test('cache value for dependencies', () => __awaiter(void 0, void 0, void 0, function* () {
+        const value1 = yield (0, rxjs_1.firstValueFrom)(fixtures.givenCacheValue((0, rxjs_1.of)(1), ['val']));
+        const value2 = yield (0, rxjs_1.firstValueFrom)(fixtures.givenCacheValue((0, rxjs_1.of)(2), ['val']));
+        expect(value1).toEqual(1);
+        expect(value2).toEqual(1);
+    }));
+});
+function getFixtures() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { act } = yield (0, make_test_module_1.makeTestModule)([]);
+        return {
+            givenCacheValue(value, dependencies) {
+                return act(() => (0, use_cache_1.useCache)(value, dependencies));
+            }
+        };
+    });
+}

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

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

package/dist/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":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,cAAc;;;EAK9C;AAED,eAAO,MAAM,iBAAiB,sBAA0C,CAAC"}

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

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

package/dist/storage/use-storage.d.ts

@@ -0,0 +1,3 @@
+import { dependency } from '../use-hash';
+export declare const useStorage: (dependencies: dependency[]) => import("./storage").Storage;
+//# sourceMappingURL=use-storage.d.ts.map

package/dist/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":"AACA,OAAO,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAIpD,eAAO,MAAM,UAAU,6DAKrB,CAAC"}

package/dist/storage/use-storage.js

@@ -0,0 +1,11 @@
+"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 use_storage_factory_1 = require("./use-storage-factory");
+exports.useStorage = (0, use_1.use)((dependencies) => {
+    const key = (0, use_hash_1.useHash)(dependencies);
+    const factory = (0, use_storage_factory_1.useStorageFactory)();
+    return factory.for(key);
+});

package/dist/strat.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from 'rxjs';
+import { Dependency } from './module';
+export declare function strat(fn: () => Observable<unknown>, dependencies: Dependency[]): {
+    fn: () => Observable<unknown>;
+    dependencies: Dependency[];
+};
+//# sourceMappingURL=strat.d.ts.map

package/dist/strat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strat.d.ts","sourceRoot":"","sources":["../src/strat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAElC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,UAAU,CAAC,OAAO,CAAC,EAAE,YAAY,EAAE,UAAU,EAAE;cAA/C,WAAW,OAAO,CAAC;;EAElD"}

package/dist/strat.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strat = void 0;
+function strat(fn, dependencies) {
+    return { fn, dependencies };
+}
+exports.strat = strat;

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

@@ -0,0 +1,29 @@
+type ExecutionMode = {
+    mode: 'REPLAY' | 'PAPER' | 'LIVE';
+    recording: boolean;
+};
+export declare function replayExecutionMode(): {
+    provide: symbol;
+    useValue: ExecutionMode;
+};
+export declare function paperExecutionMode(options: {
+    recording: boolean;
+}): {
+    provide: symbol;
+    useValue: ExecutionMode;
+};
+export declare function liveExecutionMode(options: {
+    recording: boolean;
+}): {
+    provide: symbol;
+    useValue: ExecutionMode;
+};
+export declare const useExecutionMode: () => {
+    isReplay: boolean;
+    isPaper: boolean;
+    isLive: boolean;
+    isSimulation: boolean;
+    recording: boolean;
+};
+export {};
+//# sourceMappingURL=use-execution-mode.d.ts.map

package/dist/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":"AAIA,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;IAClC,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,wBAAgB,mBAAmB;;;EAKlC;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE;;;EAKjE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE;;;EAKhE;AAED,eAAO,MAAM,gBAAgB;;;;;;CAU5B,CAAC"}

package/dist/use-execution-mode.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useExecutionMode = exports.liveExecutionMode = exports.paperExecutionMode = exports.replayExecutionMode = void 0;
+const module_1 = require("./module");
+const injectionToken = Symbol('execution-mode');
+function replayExecutionMode() {
+    return {
+        provide: injectionToken,
+        useValue: { mode: 'REPLAY', recording: false }
+    };
+}
+exports.replayExecutionMode = replayExecutionMode;
+function paperExecutionMode(options) {
+    return {
+        provide: injectionToken,
+        useValue: Object.assign({ mode: 'PAPER' }, options)
+    };
+}
+exports.paperExecutionMode = paperExecutionMode;
+function liveExecutionMode(options) {
+    return {
+        provide: injectionToken,
+        useValue: Object.assign({ mode: 'LIVE' }, options)
+    };
+}
+exports.liveExecutionMode = liveExecutionMode;
+const useExecutionMode = () => {
+    const mode = (0, module_1.useContext)(injectionToken);
+    return {
+        isReplay: mode.mode === 'REPLAY',
+        isPaper: mode.mode === 'PAPER',
+        isLive: mode.mode === 'LIVE',
+        isSimulation: mode.mode !== 'LIVE',
+        recording: mode.recording
+    };
+};
+exports.useExecutionMode = useExecutionMode;

package/dist/use-hash.d.ts

@@ -0,0 +1,5 @@
+export type dependency = {
+    toString(): string;
+} | undefined;
+export declare function useHash(dependencies: dependency[]): string;
+//# sourceMappingURL=use-hash.d.ts.map

package/dist/use-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-hash.d.ts","sourceRoot":"","sources":["../src/use-hash.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG;IAAE,QAAQ,IAAI,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC;AAE5D,wBAAgB,OAAO,CAAC,YAAY,EAAE,UAAU,EAAE,UAEjD"}

package/dist/use-hash.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useHash = void 0;
+function useHash(dependencies) {
+    return dependencies.join('/');
+}
+exports.useHash = useHash;

package/dist/use-hash.spec.d.ts

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

package/dist/use-hash.spec.d.ts.map

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

package/dist/use-hash.spec.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const asset_1 = require("./asset");
+const instrument_1 = require("./instrument");
+const use_hash_1 = require("./use-hash");
+describe(use_hash_1.useHash.name, () => {
+    it.each([
+        [[(0, asset_1.assetOf)('binance:btc')], 'binance:btc'],
+        [[(0, asset_1.assetOf)('binance:btc'), 'test'], 'binance:btc/test'],
+        [[(0, instrument_1.instrumentOf)('binance:btc-usdt')], 'binance:btc-usdt'],
+        [[(0, instrument_1.instrumentOf)('binance:btc-usdt'), 123], 'binance:btc-usdt/123']
+    ])('hash list of dependencies from %p to %p', (dependencies, hashed) => {
+        const hash = (0, use_hash_1.useHash)(dependencies);
+        expect(hash).toEqual(hashed);
+    });
+});

package/dist/use-lock.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+import { dependency } from './use-hash';
+export declare const useExclusiveLock: () => {
+    acquire: (dependencies: dependency[]) => void;
+    release: (dependencies: dependency[]) => void;
+    alreadyAcquired: (dependencies: dependency[]) => boolean;
+};
+export declare function exclusive<T>(dependencies: dependency[]): (input: Observable<T>) => Observable<T>;
+//# sourceMappingURL=use-lock.d.ts.map

package/dist/use-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-lock.d.ts","sourceRoot":"","sources":["../src/use-lock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,UAAU,EAAE,MAAM,MAAM,CAAC;AAGpD,OAAO,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAEpD,eAAO,MAAM,gBAAgB;4BAEI,UAAU,EAAE;4BAUZ,UAAU,EAAE;oCAUJ,UAAU,EAAE;CAWnD,CAAC;AAEH,wBAAgB,SAAS,CAAC,CAAC,EAAE,YAAY,EAAE,UAAU,EAAE,WACtC,WAAW,CAAC,CAAC,mBAU7B"}

package/dist/use-lock.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exclusive = exports.useExclusiveLock = void 0;
+const rxjs_1 = require("rxjs");
+const use_1 = require("./use");
+const use_hash_1 = require("./use-hash");
+exports.useExclusiveLock = (0, use_1.use)(() => {
+    const locking = {};
+    const acquire = (dependencies) => {
+        const hash = (0, use_hash_1.useHash)(dependencies);
+        if (locking[hash]) {
+            throw Error('nested locks not allowed');
+        }
+        locking[hash] = true;
+    };
+    const release = (dependencies) => {
+        const hash = (0, use_hash_1.useHash)(dependencies);
+        if (!locking[hash]) {
+            throw Error('nested locks not allowed');
+        }
+        locking[hash] = false;
+    };
+    const alreadyAcquired = (dependencies) => {
+        const hash = (0, use_hash_1.useHash)(dependencies);
+        return locking[hash] == true;
+    };
+    return {
+        acquire,
+        release,
+        alreadyAcquired
+    };
+});
+function exclusive(dependencies) {
+    return (input) => {
+        const { acquire, release, alreadyAcquired } = (0, exports.useExclusiveLock)();
+        acquire(dependencies);
+        return input.pipe((0, rxjs_1.filter)(() => alreadyAcquired(dependencies)), (0, rxjs_1.finalize)(() => release(dependencies)));
+    };
+}
+exports.exclusive = exclusive;

package/dist/{shared/logger.d.ts → use-logger.d.ts}

@@ -1,11 +1,10 @@
-export declare class Logger {
-    private readonly context;
-    constructor(context: string);
+/**
+ *
+ */
+export declare const useLogger: (context: string, tint?: string | undefined) => {
     info: (message: any, ...params: unknown[]) => void;
     debug: (message: any, ...params: unknown[]) => void;
     warn: (message: any, ...params: unknown[]) => void;
     error: (message: any, ...params: unknown[]) => void;
-    prefix: () => string;
-}
-export declare function log(context: string): Logger;
-//# sourceMappingURL=logger.d.ts.map
+};
+//# sourceMappingURL=use-logger.d.ts.map

package/dist/use-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-logger.d.ts","sourceRoot":"","sources":["../src/use-logger.ts"],"names":[],"mappings":"AAgBA;;GAEG;AACH,eAAO,MAAM,SAAS;oBAOF,GAAG,aAAa,OAAO,EAAE;qBAKxB,GAAG,aAAa,OAAO,EAAE;oBAK1B,GAAG,aAAa,OAAO,EAAE;qBAKxB,GAAG,aAAa,OAAO,EAAE;CAK5C,CAAC"}

package/dist/use-logger.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 colorize = (content) => {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < content.length; i++) {
+        hash ^= content.charCodeAt(i);
+        hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+    }
+    return chalk_1.default.hex('#' + (hash * 0xfffff * 1000000).toString(16).slice(0, 6))(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)}`;
+    return {
+        info: (message, ...params) => (params === null || params === void 0 ? void 0 : params.length)
+            ? console.info(`${prefix()}: ${message}`, params)
+            : console.info(`${prefix()}: ${message}`),
+        debug: (message, ...params) => (params === null || params === void 0 ? void 0 : params.length)
+            ? console.debug(`${prefix()}: ${message}`, params)
+            : console.debug(`${prefix()}: ${message}`),
+        warn: (message, ...params) => (params === null || params === void 0 ? void 0 : params.length)
+            ? 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}`)
+    };
+});

package/dist/use-memo.d.ts

@@ -0,0 +1,21 @@
+import { dependency } from './use-hash';
+export declare const token: unique symbol;
+/**
+ *
+ */
+export declare function memo(): {
+    provide: symbol;
+    useValue: {};
+};
+/**
+ * @name useMemo
+ * @description
+ * A hook that caches the result of an expensive calculation, based on a set of dependencies.
+ *
+ * @template T The type of the value that is memoized.
+ * @param {() => T} calculateValue A function that returns the value to memoize.
+ * @param {dependency[]} dependencies An array of dependencies that determine when the value should be recalculated.
+ * @returns {T} The memoized value.
+ */
+export declare function useMemo<T>(calculateValue: () => T, dependencies: dependency[]): T;
+//# sourceMappingURL=use-memo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-memo.d.ts","sourceRoot":"","sources":["../src/use-memo.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAEpD,eAAO,MAAM,KAAK,eAAuB,CAAC;AAE1C;;GAEG;AACH,wBAAgB,IAAI;;;EAKnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,cAAc,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,UAAU,EAAE,KAS7E"}

package/dist/use-memo.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMemo = exports.memo = exports.token = void 0;
+const module_1 = require("./module");
+const use_hash_1 = require("./use-hash");
+exports.token = Symbol('memo-token');
+/**
+ *
+ */
+function memo() {
+    return {
+        provide: exports.token,
+        useValue: {}
+    };
+}
+exports.memo = memo;
+/**
+ * @name useMemo
+ * @description
+ * A hook that caches the result of an expensive calculation, based on a set of dependencies.
+ *
+ * @template T The type of the value that is memoized.
+ * @param {() => T} calculateValue A function that returns the value to memoize.
+ * @param {dependency[]} dependencies An array of dependencies that determine when the value should be recalculated.
+ * @returns {T} The memoized value.
+ */
+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;

package/dist/use-memo.spec.d.ts

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

package/dist/use-memo.spec.d.ts.map

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

package/dist/use-memo.spec.js

@@ -0,0 +1,35 @@
+"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_memo_1 = require("./use-memo");
+describe(use_memo_1.useMemo.name, () => {
+    let fixtures;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        fixtures = yield getFixtures();
+    }));
+    test('memorize value for dependencies', () => __awaiter(void 0, void 0, void 0, function* () {
+        const value1 = yield fixtures.givenMemoValue(() => 1, [use_memo_1.useMemo.name]);
+        const value2 = yield fixtures.givenMemoValue(() => 2, [use_memo_1.useMemo.name]);
+        expect(value1).toEqual(1);
+        expect(value2).toEqual(1);
+    }));
+});
+function getFixtures() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { act } = yield (0, make_test_module_1.makeTestModule)([]);
+        return {
+            givenMemoValue(value, dependencies) {
+                return act(() => (0, use_memo_1.useMemo)(value, dependencies));
+            }
+        };
+    });
+}

package/dist/use-request.d.ts

@@ -0,0 +1,16 @@
+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>);
+}
+export declare function useRequest(args: {
+    method: RequestMethod;
+    url: string;
+    headers?: Record<string, any>;
+    body?: string;
+}): import("rxjs").Observable<{
+    timestamp: number;
+    payload: any;
+}>;
+//# sourceMappingURL=use-request.d.ts.map

package/dist/use-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-request.d.ts","sourceRoot":"","sources":["../src/use-request.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,aAAa,GACrB,KAAK,GACL,MAAM,GACN,MAAM,GACN,KAAK,GACL,QAAQ,GACR,SAAS,GACT,SAAS,GACT,OAAO,GACP,OAAO,CAAC;AAEZ,qBAAa,mBAAoB,SAAQ,KAAK;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC;gBAAxD,UAAU,EAAE,MAAM,EAAW,IAAI,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC;CAG9E;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE;IAC/B,MAAM,EAAE,aAAa,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;;;GAmBA"}

package/dist/use-request.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRequest = exports.RequestNetworkError = void 0;
+const rxjs_1 = require("rxjs");
+const undici_1 = require("undici");
+const use_timestamp_1 = require("./use-timestamp");
+class RequestNetworkError extends Error {
+    constructor(statusCode, json) {
+        super(`Request network error, received status code: ${statusCode}`);
+        this.statusCode = statusCode;
+        this.json = json;
+    }
+}
+exports.RequestNetworkError = RequestNetworkError;
+function useRequest(args) {
+    return (0, rxjs_1.from)((0, undici_1.request)(args.url, {
+        method: args.method,
+        headers: args.headers,
+        body: args.body
+    })).pipe((0, rxjs_1.switchMap)(it => {
+        if (it.statusCode !== 200) {
+            return (0, rxjs_1.throwError)(() => new RequestNetworkError(it.statusCode, () => it.body.json()));
+        }
+        return (0, rxjs_1.from)(it.body.json());
+    }), (0, rxjs_1.map)(payload => ({ timestamp: (0, use_timestamp_1.useTimestamp)(), payload })));
+}
+exports.useRequest = useRequest;

package/dist/use-socket.d.ts

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

package/dist/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,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAMlC,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,GACV,CAAC,UAAU,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,CAkDnF"}

package/dist/use-socket.js

@@ -0,0 +1,52 @@
+"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) {
+    const { debug } = (0, use_logger_1.useLogger)('useSocket');
+    const message = new rxjs_1.Observable(stream => {
+        const socket = new ws_1.WebSocket(url);
+        let isAlive = false;
+        let interval;
+        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 = () => {
+            debug('closed', url);
+            clearInterval(interval);
+            stream.error();
+        };
+        socket.onopen = () => {
+            debug('opened', url);
+            isAlive = true;
+            interval = setInterval(() => {
+                if (isAlive) {
+                    isAlive = false;
+                    socket.ping();
+                }
+                else {
+                    socket.terminate();
+                    clearInterval(interval);
+                }
+            }, 5000);
+            socket.on('pong', () => {
+                isAlive = true;
+            });
+            socket.on('ping', () => {
+                isAlive = true;
+                socket.pong();
+            });
+        };
+        return () => {
+            socket.terminate();
+            clearInterval(interval);
+        };
+    });
+    return [message, (message) => JSON.stringify(message)];
+}
+exports.useSocket = useSocket;

package/dist/use-state.d.ts

@@ -0,0 +1,4 @@
+import { Observable } from 'rxjs';
+import { dependency } from './use-hash';
+export declare function useState<T>(initialValue: T, dependencies: dependency[]): [Observable<Readonly<T>>, (value: T | ((p: T) => T)) => Readonly<T>];
+//# sourceMappingURL=use-state.d.ts.map

package/dist/use-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-state.d.ts","sourceRoot":"","sources":["../src/use-state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,UAAU,EAAE,MAAM,MAAM,CAAC;AAInD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,wBAAgB,QAAQ,CAAC,CAAC,EACxB,YAAY,EAAE,CAAC,EACf,YAAY,EAAE,UAAU,EAAE,GACzB,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAoBtE"}

package/dist/use-state.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useState = void 0;
+const rxjs_1 = require("rxjs");
+const use_memo_1 = require("./use-memo");
+function useState(initialValue, dependencies) {
+    return (0, use_memo_1.useMemo)(() => {
+        const state = new rxjs_1.BehaviorSubject(initialValue);
+        const setState = (newState) => {
+            if (newState instanceof Function) {
+                const value = newState(state.value);
+                if (value) {
+                    state.next(value);
+                }
+            }
+            else {
+                state.next(newState);
+            }
+            return state.value;
+        };
+        return [state.asObservable(), setState];
+    }, dependencies);
+}
+exports.useState = useState;

package/dist/use-state.spec.d.ts

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

package/dist/use-state.spec.d.ts.map

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

package/dist/use-state.spec.js

@@ -0,0 +1,36 @@
+"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_state_1 = require("./use-state");
+describe(use_state_1.useState.name, () => {
+    let fixtures;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        fixtures = yield getFixtures();
+    }));
+    test('keep same state between multiple requests for the same dependency', () => __awaiter(void 0, void 0, void 0, function* () {
+        const state1 = yield fixtures.givenState({ text: 'Hello my state' }, ['my-state']);
+        const state2 = yield fixtures.givenState({ text: 'Hello my override state' }, [
+            'my-state'
+        ]);
+        expect(Object.is(state1, state2)).toBeTruthy();
+    }));
+});
+function getFixtures() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { act } = yield (0, make_test_module_1.makeTestModule)([]);
+        return {
+            givenState(value, dependencies) {
+                return act(() => (0, use_state_1.useState)(value, dependencies));
+            }
+        };
+    });
+}