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

package/src/use-execution-mode.ts

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

package/src/use-logger.ts

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 
-import { use } from './use';
 import { useTimestamp } from './use-timestamp';
+import { withMemo } from './with-memo';
 
 const colorize = (content: string) => {
   let hash = 0x811c9dc5;
@@ -17,11 +17,11 @@ const colorize = (content: string) => {
 /**
  *
  */
-export const useLogger = use((context: string, tint?: string) => {
+export const useLogger = withMemo((context: string, tint?: string) => {
   const prefix = () =>
-    `${chalk.gray(new Date(useTimestamp()).toISOString())} ${chalk.hex(
-      tint ?? colorize(context)
-    )(context)}`;
+    `${chalk.hex(tint ?? colorize(context))(
+      new Date(useTimestamp()).toISOString()
+    )} ${chalk.hex(tint ?? colorize(context))(context)}`;
 
   return {
     info: (message: any, ...params: unknown[]) =>
@@ -41,7 +41,7 @@ export const useLogger = use((context: string, tint?: string) => {
 
     error: (message: any, ...params: unknown[]) =>
       params?.length
-        ? console.error(`${prefix()}: ${message}`, params)
-        : console.error(`${prefix()}: ${message}`)
+        ? console.error(`${prefix()}: ${chalk.red(message)}`, params)
+        : console.error(`${prefix()}: ${chalk.red(message)}`)
   };
 });

package/src/use-memo.ts

@@ -1,28 +1,8 @@
-import { useContext } from '@lib/module';
+import { Dependency, useContext } from '@lib/module';
 import { dependency, useHash } from '@lib/use-hash';
 
 export const token = Symbol('memo-token');
 
-/**
- *
- */
-export function memo() {
-  return {
-    provide: token,
-    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 function useMemo<T>(calculateValue: () => T, dependencies: dependency[]) {
   const memory = useContext<Record<string, any>>(token);
   const hash = useHash(dependencies);
@@ -33,3 +13,8 @@ export function useMemo<T>(calculateValue: () => T, dependencies: dependency[])
 
   return (memory[hash] = calculateValue()) as T;
 }
+
+useMemo.options = (): Dependency => ({
+  provide: token,
+  useValue: {}
+});

package/src/use-socket.ts

@@ -1,59 +1,78 @@
-import { Observable } from 'rxjs';
+import { defer, Observable, of } from 'rxjs';
 import { WebSocket } from 'ws';
 
 import { useLogger } from './use-logger';
 import { useTimestamp } from './use-timestamp';
 
 export function useSocket(
-  url: string
-): [Observable<{ timestamp: number; payload: unknown }>, (message: unknown) => void] {
+  url: string,
+  options: { pingInterval?: number } = { pingInterval: 5000 }
+) {
   const { debug } = useLogger('useSocket');
+  const socket = new WebSocket(url);
 
-  const message = new Observable<{ timestamp: number; payload: unknown }>(stream => {
-    const socket = new WebSocket(url);
-    let isAlive = false;
-    let interval: NodeJS.Timer | undefined;
-
-    socket.onmessage = it =>
-      stream.next({ timestamp: useTimestamp(), payload: JSON.parse(it.data as string) });
-    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();
+  return {
+    /**
+     * 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 }> {
+      let isAlive = false;
+      let interval: NodeJS.Timeout | undefined;
+
+      return new Observable(stream => {
+        socket.onmessage = it =>
+          stream.next({
+            timestamp: useTimestamp(),
+            payload: JSON.parse(it.data as string)
+          });
+        socket.onerror = it => {
+          clearInterval(interval);
+          debug('errored', url);
+          stream.error(it);
+        };
+        socket.onclose = () => {
+          debug('closed', url);
           clearInterval(interval);
-        }
-      }, 5000);
+          stream.error();
+        };
+        socket.onopen = () => {
+          debug('opened', url);
+          isAlive = true;
+          interval = setInterval(() => {
+            if (isAlive) {
+              isAlive = false;
 
-      socket.on('pong', () => {
-        isAlive = true;
-      });
+              socket.ping();
+            } else {
+              socket.terminate();
+              clearInterval(interval);
+            }
+          }, options.pingInterval);
+
+          socket.on('pong', () => {
+            isAlive = true;
+          });
 
-      socket.on('ping', () => {
-        isAlive = true;
-        socket.pong();
+          socket.on('ping', () => {
+            isAlive = true;
+            socket.pong();
+          });
+        };
+
+        return () => {
+          clearInterval(interval);
+          socket.terminate();
+        };
       });
-    };
+    },
 
-    return () => {
-      socket.terminate();
-      clearInterval(interval);
-    };
-  });
+    send(message: { payload: unknown }): Observable<{ timestamp: number }> {
+      return defer(() => {
+        socket.send(JSON.stringify(message.payload));
 
-  return [message, (message: unknown) => JSON.stringify(message)];
+        return of({ timestamp: useTimestamp() });
+      });
+    }
+  };
 }

package/src/use-timestamp.ts

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

package/src/when-socket.ts

@@ -0,0 +1,61 @@
+import { Observable } from 'rxjs';
+import { WebSocket } from 'ws';
+
+import { useLogger } from './use-logger';
+import { useTimestamp } from './use-timestamp';
+
+export function whenSocket(
+  url: string,
+  options: { pingInterval?: number } = { pingInterval: 5000 }
+): [Observable<{ timestamp: number; payload: unknown }>, (message: unknown) => void] {
+  const { debug } = useLogger('whenSocket');
+
+  const message = new Observable<{ timestamp: number; payload: unknown }>(stream => {
+    const socket = new WebSocket(url);
+    let isAlive = false;
+    let interval: NodeJS.Timeout | undefined;
+
+    socket.onmessage = it =>
+      stream.next({ timestamp: useTimestamp(), payload: JSON.parse(it.data as string) });
+    socket.onerror = it => {
+      clearInterval(interval);
+      debug('errored', url);
+      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);
+        }
+      }, options.pingInterval);
+
+      socket.on('pong', () => {
+        isAlive = true;
+      });
+
+      socket.on('ping', () => {
+        isAlive = true;
+        socket.pong();
+      });
+    };
+
+    return () => {
+      socket.terminate();
+      clearInterval(interval);
+    };
+  });
+
+  return [message, (message: unknown) => JSON.stringify(message)];
+}

package/src/{use.spec.ts → with-memo.spec.ts}

@@ -1,9 +1,9 @@
 import { makeTestModule } from '@lib/make-test-module';
 
 import { instrumentOf, InstrumentSelector } from './instrument';
-import { use } from './use';
+import { withMemo } from './with-memo';
 
-describe(use.name, () => {
+describe(withMemo.name, () => {
   let fixtures: Awaited<ReturnType<typeof getFixtures>>;
 
   beforeEach(async () => {
@@ -37,7 +37,7 @@ describe(use.name, () => {
 async function getFixtures() {
   const { act } = await makeTestModule([]);
 
-  const getValue = use((instrument: InstrumentSelector) => instrument.id);
+  const getValue = withMemo((instrument: InstrumentSelector) => instrument.id);
 
   return {
     act,

package/src/{use.ts → with-memo.ts}

@@ -1,19 +1,19 @@
 import { isObservable, Observable, shareReplay } from 'rxjs';
 import { v4 } from 'uuid';
 
-import { asReadonly } from './as-readonly';
 import { throwWithContext } from './module';
+import { asReadonly } from './operators';
 import { dependency } from './use-hash';
 import { useMemo } from './use-memo';
 
-export function use<T extends Array<dependency>, U>(
+export function withMemo<T extends Array<dependency>, U>(
   fn: (...args: T) => U
 ): (...args: T) => U;
-export function use<T extends Array<dependency>, U>(
+export function withMemo<T extends Array<dependency>, U>(
   fn: (...args: T) => Observable<U>
 ): (...args: T) => Observable<U>;
 
-export function use<T extends Array<dependency>, U>(
+export function withMemo<T extends Array<dependency>, U>(
   fn: (...args: T) => U | Observable<U>
 ): (...args: T) => U | Observable<U> {
   throwWithContext();

package/src/with-request.ts

@@ -0,0 +1,83 @@
+import { randomUUID } from 'node:crypto';
+import { Observable } from 'rxjs';
+import { request } from 'undici';
+
+import { useLogger } from './use-logger';
+import { useTimestamp } from './use-timestamp';
+
+export type RequestMethod =
+  | 'GET'
+  | 'HEAD'
+  | 'POST'
+  | 'PUT'
+  | 'DELETE'
+  | 'CONNECT'
+  | 'OPTIONS'
+  | 'TRACE'
+  | 'PATCH';
+
+export class RequestNetworkError extends Error {
+  constructor(readonly statusCode: number) {
+    super(`Request network error, received status code: ${statusCode}`);
+  }
+}
+
+export function withRequest({
+  method,
+  url,
+  headers,
+  body
+}: {
+  method: RequestMethod;
+  url: string;
+  headers?: Record<string, any>;
+  body?: string;
+}) {
+  const { error, debug } = useLogger(withRequest.name);
+
+  return new Observable<{ timestamp: number; payload: unknown }>(subscriber => {
+    const correlationId = randomUUID();
+
+    debug('requesting', { correlationId, method, url, headers, body });
+
+    request(url, { method, headers, body })
+      .then(async ({ statusCode, body }) => {
+        const json = await body.json();
+
+        debug('received', {
+          correlationId,
+          method,
+          url,
+          headers,
+          body: json,
+          statusCode
+        });
+
+        if (statusCode !== 200) {
+          error(`errored`, {
+            method,
+            url,
+            headers,
+            body,
+            statusCode
+          });
+
+          subscriber.error(new RequestNetworkError(statusCode));
+        } else {
+          subscriber.next({ timestamp: useTimestamp(), payload: json });
+        }
+      })
+      .catch((e: Error) => {
+        error(`errored`, {
+          method,
+          url,
+          headers,
+          body,
+          error: e
+        });
+
+        subscriber.error(error);
+      })
+      .finally(() => subscriber.complete());
+  });
+}

package/tsconfig.json

@@ -3,7 +3,7 @@
   "compilerOptions": {
     "rootDir": "src",
     "baseUrl": ".",
-    "outDir": "dist",
+    "outDir": "lib",
     "paths": {
       "@lib/*": ["src/*"]
     }
@@ -13,6 +13,6 @@
   ],
   "exclude": [
     "jest.config.js",
-    "dist/**/*"
+    "lib/**/*"
   ]
 }

package/dist/as-readonly.d.ts

@@ -1,3 +0,0 @@
-import { Observable } from 'rxjs';
-export declare function asReadonly<T>(): (input: Observable<T>) => Observable<Readonly<T>>;
-//# sourceMappingURL=as-readonly.d.ts.map

package/dist/as-readonly.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"as-readonly.d.ts","sourceRoot":"","sources":["../src/as-readonly.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,UAAU,EAAE,MAAM,MAAM,CAAC;AAEvC,wBAAgB,UAAU,CAAC,CAAC,aACX,WAAW,CAAC,CAAC,6BAC7B"}

package/dist/as-readonly.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asReadonly = void 0;
-const rxjs_1 = require("rxjs");
-function asReadonly() {
-    return (input) => input.pipe((0, rxjs_1.map)(it => it));
-}
-exports.asReadonly = asReadonly;

package/dist/asset/asset.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset.d.ts","sourceRoot":"","sources":["../../src/asset/asset.ts"],"names":[],"mappings":"AACA,OAAO,EAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAEzC,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C;;GAEG;AACH,qBAAa,aAAa;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;gBAEjB,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAc7C,QAAQ;CAGT;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,CAQvD;AAED;;;GAGG;AACH,qBAAa,KAAM,SAAQ,aAAa;aAGyB,KAAK,EAAE,MAAM;IAF5E,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;gBAEf,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAkB,KAAK,EAAE,MAAM;IAU5E;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM;IAI9B;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO;IAI/B;;OAEG;IACH,IAAI,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO;CAG/B"}

package/dist/cli/dev.d.ts

@@ -1,2 +0,0 @@
-export default function (name: string, options: any): Promise<void>;
-//# sourceMappingURL=dev.d.ts.map

package/dist/cli/dev.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/cli/dev.ts"],"names":[],"mappings":"AAUA,yBAA+B,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,iBAoBxD"}

package/dist/cli/dev.js

@@ -1,61 +0,0 @@
-"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const rxjs_1 = require("rxjs");
-const build_1 = __importDefault(require("../cli/build"));
-const workspace_1 = require("../cli/internal/workspace");
-const core_1 = require("../core");
-const module_1 = require("../module");
-const use_execution_mode_1 = require("../use-execution-mode");
-function default_1(name, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (yield (0, build_1.default)()) {
-            return;
-        }
-        const script = (yield Promise.resolve(`${(0, path_1.join)((0, workspace_1.buildDirectory)(), name)}`).then(s => __importStar(require(s)))).default;
-        const module = new module_1.Module([
-            ...(0, core_1.core)(),
-            ...script.dependencies,
-            (0, use_execution_mode_1.paperExecutionMode)({ recording: false })
-        ]);
-        const { act } = yield module.awake();
-        const output = yield act(() => (0, rxjs_1.lastValueFrom)(script.fn()));
-        console.log(output);
-    });
-}
-exports.default = default_1;

package/dist/cli/pull.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pull.d.ts","sourceRoot":"","sources":["../../src/cli/pull.ts"],"names":[],"mappings":"AAUA,yBAA+B,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,iBAgE5E"}