@quantform/core 0.3.217 → 0.3.222

package/src/session/session.ts

@@ -3,6 +3,7 @@ import {
   filter,
   map,
   mergeMap,
+  share,
   shareReplay,
   startWith,
   switchMap,
@@ -20,13 +21,12 @@ import {
   OrderState
 } from '../domain';
 import { Store } from '../store';
-import { from, Observable, Subscription } from 'rxjs';
+import { concat, from, Observable, Subject, Subscription } from 'rxjs';
 import { Behaviour, CombinedBehaviour, FunctionBehaviour } from '../behaviour';
 import { AdapterAggregate } from '../adapter/adapter-aggregate';
 import { Worker } from '../common';
 import { Trade } from '../domain/trade';
 import { SessionDescriptor } from './session-descriptor';
-import { Measure } from '../storage/measurement';
 import {
   AdapterHistoryQuery,
   AdapterOrderCancelCommand,
@@ -34,12 +34,18 @@ import {
   AdapterSubscribeCommand
 } from '../adapter';
 
+type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
+
 export class Session {
   private initialized = false;
   private subscription: Subscription;
   private behaviour: Behaviour;
   private worker = new Worker();
 
+  get timestamp(): number {
+    return this.store.snapshot.timestamp;
+  }
+
   constructor(
     readonly store: Store,
     readonly aggregate: AdapterAggregate,
@@ -83,33 +89,57 @@ export class Session {
     await this.worker.wait();
   }
 
-  save(...measure: Measure[]) {
-    if (!this.descriptor?.measurement) {
+  statement(output: Record<string, any>) {
+    if (!this.behaviour?.statement) {
       return;
     }
 
-    this.worker.enqueue(() =>
-      this.descriptor.measurement.save(this.descriptor.id, measure)
-    );
+    this.behaviour.statement(output);
   }
 
-  query(params: { type: string; timestamp?: number }): Observable<Measure> {
-    return from(
+  useMeasure<T extends { timestamp: number }>(
+    params: { key: string; timestamp?: number },
+    defaultValue: T = undefined
+  ): [Observable<T>, (value: Optional<T, 'timestamp'>) => void] {
+    const stored$ = from(
       this.descriptor.measurement.query(this.descriptor.id, {
-        type: params.type,
-        timestamp: params.timestamp ?? this.store.snapshot.timestamp,
+        type: params.key,
+        timestamp: params.timestamp ?? this.timestamp,
         limit: 1,
         direction: 'BACKWARD'
       })
-    ).pipe(map(it => it[0]));
+    ).pipe(
+      map(it =>
+        it.length ? { timestamp: it[0].timestamp, ...it[0].payload } : defaultValue
+      ),
+      share()
+    );
+
+    const subject$ = new Subject<T>();
+
+    const setter = (value: T) => {
+      const timestamp = value.timestamp ?? this.timestamp;
+      const measure = { timestamp, type: params.key, payload: value };
+
+      this.worker.enqueue(() =>
+        this.descriptor.measurement.save(this.descriptor.id, [measure])
+      );
+
+      subject$.next({ ...value, timestamp });
+    };
+
+    return [concat(stored$, subject$.asObservable()), setter];
   }
 
-  statement(output: Record<string, any>) {
-    if (!this.behaviour?.statement) {
-      return;
-    }
+  useOptimizer(path: string): any {
+    const session = this;
+    const [order$, setOrderMeasure] = session.useMeasure(
+      { key: 'ordered' },
+      { limt: 10, timestamp: 0 }
+    );
 
-    this.behaviour.statement(output);
+    setOrderMeasure({ limt: 0, timestamp: 0 });
+    return undefined;
   }
 
   async subscribe(instrument: Array<InstrumentSelector>): Promise<void> {

package/src/storage/measurement.ts

@@ -3,8 +3,7 @@ import { timestamp } from '../common';
 export interface Measure {
   timestamp: timestamp;
   type: string;
-
-  [key: string]: any;
+  payload: any;
 }
 
 export interface Measurement {

package/dist/indicator/window-indicator.d.ts

@@ -1,10 +0,0 @@
-import { RingBuffer } from './ring-buffer';
-export declare abstract class WindowIndicator<T> {
-    private _buffer;
-    get capacity(): number;
-    get size(): number;
-    get isCompleted(): boolean;
-    constructor(capacity: number);
-    abstract calculate(added: T, removed: T, buffer: RingBuffer<T>): any;
-    append(value: T): void;
-}

package/dist/indicator/window-indicator.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WindowIndicator = void 0;
-const ring_buffer_1 = require("./ring-buffer");
-class WindowIndicator {
-    constructor(capacity) {
-        this._buffer = new ring_buffer_1.RingBuffer(capacity);
-    }
-    get capacity() {
-        return this._buffer.capacity;
-    }
-    get size() {
-        return this._buffer.size;
-    }
-    get isCompleted() {
-        return this._buffer.isFull;
-    }
-    append(value) {
-        let removed = null;
-        if (this.isCompleted) {
-            removed = this._buffer.peek();
-        }
-        this._buffer.enqueue(value);
-        this.calculate(value, removed, this._buffer);
-    }
-}
-exports.WindowIndicator = WindowIndicator;
-//# sourceMappingURL=window-indicator.js.map

package/dist/indicator/window-indicator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"window-indicator.js","sourceRoot":"","sources":["../../src/indicator/window-indicator.ts"],"names":[],"mappings":";;;AAAA,+CAA2C;AAE3C,MAAsB,eAAe;IAenC,YAAY,QAAgB;QAC1B,IAAI,CAAC,OAAO,GAAG,IAAI,wBAAU,CAAI,QAAQ,CAAC,CAAC;IAC7C,CAAC;IAdD,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;IAC/B,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;IAC3B,CAAC;IAED,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;IAC7B,CAAC;IAQM,MAAM,CAAC,KAAQ;QACpB,IAAI,OAAO,GAAG,IAAI,CAAC;QAEnB,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;SAC/B;QAED,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAE5B,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IAC/C,CAAC;CACF;AAhCD,0CAgCC"}

package/src/indicator/window-indicator.ts

@@ -1,35 +0,0 @@
-import { RingBuffer } from './ring-buffer';
-
-export abstract class WindowIndicator<T> {
-  private _buffer: RingBuffer<T>;
-
-  get capacity(): number {
-    return this._buffer.capacity;
-  }
-
-  get size(): number {
-    return this._buffer.size;
-  }
-
-  get isCompleted(): boolean {
-    return this._buffer.isFull;
-  }
-
-  constructor(capacity: number) {
-    this._buffer = new RingBuffer<T>(capacity);
-  }
-
-  abstract calculate(added: T, removed: T, buffer: RingBuffer<T>);
-
-  public append(value: T) {
-    let removed = null;
-
-    if (this.isCompleted) {
-      removed = this._buffer.peek();
-    }
-
-    this._buffer.enqueue(value);
-
-    this.calculate(value, removed, this._buffer);
-  }
-}