@quantform/core 0.3.215 → 0.3.221

package/src/indicator/wma.ts

@@ -1,55 +1,27 @@
 import { Observable } from 'rxjs';
 import { filter, map, share } from 'rxjs/operators';
-import { RingBuffer } from './ring-buffer';
-import { SMA } from './sma';
-import { WindowIndicator } from './window-indicator';
+import { window } from './window';
 
-export class WMA extends WindowIndicator<number> {
-  private _k = 0;
-  private _sma: SMA;
-  private _value: number;
-
-  get value(): number {
-    return this._value;
-  }
-
-  constructor(capacity: number) {
-    super(capacity);
-
-    this._k = 1.0 / capacity;
-    this._sma = new SMA(capacity);
-  }
-
-  calculate(added: number, removed: number, buffer: RingBuffer<number>) {
-    if (!this.isCompleted) {
-      return;
-    }
-
-    let norm = 0.0;
-    let sum = 0.0;
-
-    for (let i = 0; i < this.capacity; i++) {
-      const weight = (this.capacity - i) * this.capacity;
-      norm = norm + weight;
-
-      sum = sum + buffer.at(this.capacity - (i + 1)) * weight;
-    }
+export function wma<T>(length: number, fn: (it: T) => number) {
+  return function (source: Observable<T>): Observable<[T, number]> {
+    return source.pipe(
+      window(length, fn),
+      filter(([, buffer]) => buffer.isFull),
+      map(([it, buffer]) => {
+        let norm = 0.0;
+        let sum = 0.0;
 
-    this._value = sum / norm;
-  }
-}
+        for (let i = 0; i < buffer.capacity; i++) {
+          const weight = (buffer.capacity - i) * buffer.capacity;
 
-export function wma<T>(length: number, fn: (it: T) => number) {
-  return function(source: Observable<T>): Observable<WMA> {
-    const indicator = new WMA(length);
+          norm = norm + weight;
+          sum = sum + buffer.at(buffer.capacity - (i + 1)) * weight;
+        }
 
-    return source.pipe(
-      filter(it => {
-        indicator.append(fn(it));
+        const tuple: [T, number] = [it, sum / norm];
 
-        return indicator.isCompleted;
+        return tuple;
       }),
-      map(_ => indicator),
       share()
     );
   };

package/src/session/session-descriptor.ts

@@ -24,7 +24,5 @@ export interface SessionDescriptor {
    */
   measurement?: Measurement;
 
-  template?: string;
-
   behaviour?: Behaviour | Behaviour[] | ((session: Session) => Observable<any>);
 }

package/src/session/session-optimizer.ts

@@ -1,5 +1,5 @@
 export function fit(key: string, generator?: any[]) {
-  return function(target: any, propertyKey: string) {
+  return function (target: any, propertyKey: string) {
     let defaultSetterValue;
 
     if (generator) {

package/src/session/session.ts

@@ -83,33 +83,38 @@ 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 Measure>(
+    params: { key: string; timestamp?: number },
+    defaultValue: T = undefined
+  ): [Observable<T>, (value: T) => void] {
+    const query$ = from(
       this.descriptor.measurement.query(this.descriptor.id, {
-        type: params.type,
+        type: params.key,
         timestamp: params.timestamp ?? this.store.snapshot.timestamp,
         limit: 1,
         direction: 'BACKWARD'
       })
-    ).pipe(map(it => it[0]));
-  }
+    ).pipe(map(it => (it.length ? (it[0] as T) : defaultValue)));
 
-  statement(output: Record<string, any>) {
-    if (!this.behaviour?.statement) {
-      return;
-    }
+    const setter = (value: T) => {
+      this.worker.enqueue(() =>
+        this.descriptor.measurement.save(this.descriptor.id, [value])
+      );
+    };
 
-    this.behaviour.statement(output);
+    return [query$, setter];
+  }
+
+  useOptimizer(path: string): any {
+    return 0;
   }
 
   async subscribe(instrument: Array<InstrumentSelector>): Promise<void> {

package/src/store/event/store-candle.event.ts

@@ -1,5 +1,7 @@
+import { TradePatchEventHandler } from './store-trade.event';
 import { timestamp } from '../../common/datetime';
 import { InstrumentSelector } from '../../domain';
+import { State } from '../store.state';
 import { StoreEvent } from './store.event';
 
 export class CandleEvent implements StoreEvent {
@@ -16,3 +18,16 @@ export class CandleEvent implements StoreEvent {
     readonly timestamp: timestamp
   ) {}
 }
+
+export function CandleEventHandler(event: CandleEvent, state: State) {
+  return TradePatchEventHandler(
+    {
+      type: 'trade-patch',
+      instrument: event.instrument,
+      quantity: event.volume,
+      rate: event.close,
+      timestamp: event.timestamp
+    },
+    state
+  );
+}

package/src/store/store.ts

@@ -14,6 +14,8 @@ import {
   BalanceTransactEventHandler,
   BalanceUnfreezEvent,
   BalanceUnfreezEventHandler,
+  CandleEvent,
+  CandleEventHandler,
   InstrumentPatchEvent,
   InstrumentPatchEventHandler,
   InstrumentSubscriptionEvent,
@@ -222,4 +224,12 @@ export class Store extends Topic<StoreEvent, any> {
   onTradePatch(event: TradePatchEvent) {
     return TradePatchEventHandler(event, this.snapshot);
   }
+
+  /**
+   * @see CandleEventHandler
+   */
+  @handler(CandleEvent)
+  onCandle(event: CandleEvent) {
+    return CandleEventHandler(event, this.snapshot);
+  }
 }

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);
-  }
-}