jspurefix 2.2.1 → 3.0.0

package/src/buffer/ascii/time-formatter.ts

@@ -56,31 +56,31 @@ export class TimeFormatter implements ITimeFormatter {
     buffer.writePaddedHundreds(ms)
   }
 
-  public getLocalTime (start: number): Date {
+  public getLocalTime (start: number): Date | null {
     return this.getTime(start, false)
   }
 
-  public getUtcTime (start: number): Date {
+  public getUtcTime (start: number): Date | null {
     return this.getTime(start, true)
   }
 
-  public getUtcDate (start: number): Date {
+  public getUtcDate (start: number): Date | null {
     return this.getDate(start, true)
   }
 
-  public getLocalDate (start: number): Date {
+  public getLocalDate (start: number): Date | null {
     return this.getDate(start, false)
   }
 
-  public getUtcTimestamp (start: number, end: number): Date {
-    return this.getTimestamp(start, end,true)
+  public getUtcTimestamp (start: number, end: number): Date | null {
+    return this.getTimestamp(start, end, true)
   }
 
-  public getLocalTimestamp (start: number, end: number): Date {
-    return this.getTimestamp(start, end,false)
+  public getLocalTimestamp (start: number, end: number): Date | null {
+    return this.getTimestamp(start, end, false)
   }
 
-  private getTimestamp (start: number, end: number, useUtc: boolean): Date {
+  private getTimestamp (start: number, end: number, useUtc: boolean): Date | null {
     const buffer = this.buffer
     const n: number = buffer.getWholeNumber(start, start + 7)
     if (n == null) {
@@ -145,7 +145,7 @@ export class TimeFormatter implements ITimeFormatter {
     return t
   }
 
-  private getTime (start: number, useUtc: boolean): Date {
+  private getTime (start: number, useUtc: boolean): Date | null {
     const buffer = this.buffer
     let offset = 0
     const hh: number = buffer.getWholeNumber(start + offset, start + offset + 1)
@@ -179,8 +179,7 @@ export class TimeFormatter implements ITimeFormatter {
     return t
   }
 
-  private getDate (start: number, useUtc: boolean): Date {
-
+  private getDate (start: number, useUtc: boolean): Date | null {
     // = 20150417
 
     const n: number = this.buffer.getWholeNumber(start, start + 7)

package/src/buffer/elastic-buffer.ts

@@ -10,8 +10,7 @@ export class ElasticBuffer {
   private stretched: number
 
   constructor (@inject(DITokens.elasticBufferSize) public readonly size: number = 6 * 1024,
-               @inject(DITokens.elasticBufferReturnSize) public readonly returnTo: number = 6 * 1024) {
-
+    @inject(DITokens.elasticBufferReturnSize) public readonly returnTo: number = 6 * 1024) {
     this.size = Math.max(1, this.size)
     this.buffer = Buffer.allocUnsafe(this.size)
     this.returnTo = Math.max(this.size, this.returnTo)
@@ -117,7 +116,7 @@ export class ElasticBuffer {
     return this.ptr
   }
 
-  public writeNumber (v: number, places: number = 13) {
+  public writeNumber (v: number, places: number = 13): number {
     const rounded: number = Math.floor(v)
     const fraction: number = ElasticBuffer.precisionRound(v - rounded, places)
     if (fraction === 0) {
@@ -141,7 +140,7 @@ export class ElasticBuffer {
   }
 
   public slice (): Buffer {
-    return this.buffer.slice(0, this.ptr)
+    return this.buffer.subarray(0, this.ptr)
   }
 
   public copy (): Buffer {
@@ -251,7 +250,7 @@ export class ElasticBuffer {
   }
 
   public getBuffer (start: number, end: number): Buffer {
-    return this.buffer.slice(start, end)
+    return this.buffer.subarray(start, end)
   }
 
   public getBoolean (start: number): boolean {
@@ -259,7 +258,7 @@ export class ElasticBuffer {
     return b === AsciiChars.Y
   }
 
-  public getFloat (start: number, vend: number): number {
+  public getFloat (start: number, vend: number): number | null {
     let n: number = 0
     let digits: number = 0
     let dotPosition: number = 0

package/src/buffer/encode-proxy.ts

@@ -33,14 +33,14 @@ export class EncodeProxy {
       }
 
       case TagType.Boolean: {
-        if (typeof(val) !== typeof(true)) {
+        if (typeof (val) !== typeof (true)) {
           throw new Error(`field ${field.name} expects boolean but receives "${typeof val}"`)
         }
         break
       }
 
       case TagType.String: {
-        if (typeof(val) !== 'string') {
+        if (typeof (val) !== 'string') {
           throw new Error(`field ${field.name} expects string but receives "${typeof val}"`)
         }
         break
@@ -67,7 +67,7 @@ export class EncodeProxy {
 
   private static checkProperties (wrapped: ILooseObject, val: ILooseObject): ILooseObject {
     const keys: string[] = Object.keys(val)
-    for (let k of keys) {
+    for (const k of keys) {
       wrapped[k] = val[k]
     }
     return wrapped
@@ -108,7 +108,7 @@ export class EncodeProxy {
   private static handler (set: ContainedFieldSet): Object {
     return {
       set (target: ILooseObject, prop: string, val: any): boolean {
-        const field: ContainedField = set.localNameToField.get(prop)
+        const field: ContainedField | null = set.localNameToField.get(prop)
         if (!field) {
           throw new Error(`type ${set.name} has no field named ${prop}`)
         }
@@ -137,8 +137,9 @@ export class EncodeProxy {
     }
     return val
   }
+
   public wrap (msgName: string): ILooseObject {
-    const msg: MessageDefinition = this.definitions.message.get(msgName)
+    const msg: MessageDefinition | null = this.definitions.message.get(msgName)
     if (!msg) {
       throw new Error(`no message defined for type ${msgName}`)
     }

package/src/buffer/encoder-state.ts

@@ -2,11 +2,15 @@ export class EncodedStatus {
   public ptr: number = 0
   public bodyLengthPos: number
   public bodyEndPos: number
-  public begin: Date
-  public end: Date
+  public begin: Date | null
+  public end: Date | null
   public elapsed (): number {
-    return this.begin.getTime() - this.end.getTime()
+    if (this.begin && this.end) {
+      return this.begin.getTime() - this.end.getTime()
+    }
+    return 0
   }
+
   public reset (): void {
     this.ptr = 0
     this.bodyLengthPos = 0

package/src/buffer/fixml/fixml-encoder.ts

@@ -63,12 +63,13 @@ export class FixmlEncoder extends MsgEncoder {
         return moment(d).utc(true).format('YYYY-MM-DD')
       }
     }
+    return ''
   }
 
   public encodeSet (o: ILooseObject, set: ContainedFieldSet): void {
     const batch: ILooseObject[] = o.Batch
     const toWrite: ILooseObject[] = batch || [o]
-    let depth = batch ? 1 : 0
+    const depth = batch ? 1 : 0
     const buffer = this.buffer
     const begin = this.beginDoc
     const indent: string = '\t'
@@ -80,7 +81,7 @@ export class FixmlEncoder extends MsgEncoder {
       this.batchStart(o, set, depth)
     }
     toWrite.forEach((next: ILooseObject) => {
-      this.toXml(next, set.abbreviation, set, depth + 1)
+      this.toXml(next, set.abbreviation ?? '', set, depth + 1)
       buffer.writeString(eol)
     })
     if (batch) {
@@ -90,7 +91,7 @@ export class FixmlEncoder extends MsgEncoder {
     buffer.writeString(this.endDoc)
   }
 
-  private batchStart (o: ILooseObject, set: ContainedFieldSet, depth: number) {
+  private batchStart (o: ILooseObject, set: ContainedFieldSet, depth: number): void {
     const buffer = this.buffer
     const indent: string = '\t'
     const beginBatch = this.beginBatch
@@ -105,7 +106,6 @@ export class FixmlEncoder extends MsgEncoder {
   }
 
   private toXml (o: ILooseObject, name: string, set: ContainedFieldSet, depth: number): void {
-
     const buffer = this.buffer
     const selfClose: string = '/>'
     const close: string = '>'
@@ -131,7 +131,7 @@ export class FixmlEncoder extends MsgEncoder {
   private getPopulatedFields (set: ContainedFieldSet, o: ILooseObject): ContainedField[] {
     const keys: string[] = Object.keys(o)
     const fields: ContainedField[] = keys.reduce((a: ContainedField[], current: string) => {
-      const field: ContainedField = set.localNameToField.get(current)
+      const field: ContainedField | null = set.localNameToField.get(current)
       if (field && !set.nameToLocalAttribute.containsKey(current)) {
         a.push(field)
       }
@@ -176,7 +176,7 @@ export class FixmlEncoder extends MsgEncoder {
   }
 
   private getPopulatedAttributes (o: ILooseObject, attributes: ContainedSimpleField[]): IPopulatedAttributes {
-    return attributes.reduce((a: IPopulatedAttributes, f: ContainedSimpleField) => {
+    return attributes.reduce<IPopulatedAttributes>((a: IPopulatedAttributes, f: ContainedSimpleField) => {
       let v: any = o[f.definition.name]
       if (v == null) {
         v = o[f.name]
@@ -189,17 +189,17 @@ export class FixmlEncoder extends MsgEncoder {
     }, {
       values: [],
       fields: []
-    } as IPopulatedAttributes)
+    })
   }
 
-  private complexGroup (o: ILooseObject, field: ContainedField, depth: number) {
+  private complexGroup (o: ILooseObject, field: ContainedField, depth: number): void {
     const gf: ContainedGroupField = field as ContainedGroupField
     const elements: ILooseObject[] = o[gf.definition.name]
     if (elements) {
       if (Array.isArray(elements)) {
         for (const e of elements) {
           this.buffer.writeString(this.eol)
-          this.toXml(e, gf.name, gf.definition,depth + 1)
+          this.toXml(e, gf.name, gf.definition, depth + 1)
         }
       } else {
         throw new Error(`expected array for member ${gf.definition.name}`)
@@ -207,7 +207,7 @@ export class FixmlEncoder extends MsgEncoder {
     }
   }
 
-  private complexComponent (o: ILooseObject, field: ContainedField, depth: number) {
+  private complexComponent (o: ILooseObject, field: ContainedField, depth: number): void {
     const cf: ContainedComponentField = field as ContainedComponentField
     const def = cf.definition
     const instance: ILooseObject = o[def.name]

package/src/buffer/fixml/fixml-parser.ts

@@ -2,9 +2,11 @@ import { MsgParser } from '../msg-parser'
 import { Tags } from '../tag/tags'
 import { SAXStream } from '../../dictionary'
 import { FixDefinitions, MessageDefinition } from '../../dictionary/definition'
-import { ContainedField, ContainedComponentField,
+import {
+  ContainedField, ContainedComponentField,
   ContainedFieldType, ContainedGroupField,
-  ContainedSimpleField, ContainedFieldSet } from '../../dictionary/contained'
+  ContainedSimpleField, ContainedFieldSet
+} from '../../dictionary/contained'
 import { SegmentDescription } from '../segment/segment-description'
 import { IJsFixConfig, IJsFixLogger } from '../../config'
 import { MsgView } from '../msg-view'
@@ -25,16 +27,16 @@ export class FiXmlParser extends MsgParser {
   private readonly segments: SegmentDescription[] = []
   private readonly segmentStack: SegmentDescription[] = []
   private readonly logger: IJsFixLogger
-  private last: SegmentDescription
-  private raw: string
+  private last: SegmentDescription | null
+  private raw: string | null
 
   constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig,
-               @inject(DITokens.readStream) public readonly readStream: Readable,
-               @inject(DITokens.maxMessageLocations) public readonly maxMessageLocations: number = 10 * 1024) {
+    @inject(DITokens.readStream) public readonly readStream: Readable,
+    @inject(DITokens.maxMessageLocations) public readonly maxMessageLocations: number = 10 * 1024) {
     super()
     this.definitions = this.config.definitions
     const description = config.description
-    const me = description.application.name
+    const me = description?.application?.name
     this.logger = config.logFactory.logger(`${me}:FiXmlParser`)
     this.saxStream = require('sax').createStream(true, {})
     this.locations = new Tags(this.definitions, maxMessageLocations)
@@ -60,7 +62,7 @@ export class FiXmlParser extends MsgParser {
   private subscribe (): void {
     const writeStream = this.saxStream
     const readStream = this.readStream
-    let instance = this
+    const instance = this
     readStream.pipe(writeStream).on('ready', () => {
       this.logger.info('stream close event')
       this.emit('close')
@@ -138,13 +140,17 @@ export class FiXmlParser extends MsgParser {
     if (stack.length === 0) {
       throw new Error(`Hdr not expected before batch or message ${saxNode.name}`)
     }
-    let peek: SegmentDescription = stack[stack.length - 1]
+    const peek: SegmentDescription = stack[stack.length - 1]
     switch (peek.type) {
       case SegmentType.Batch: {
         // manually handle this component
         const hdr = this.definitions.component.get('StandardHeader')
-        const segment: SegmentDescription = this.parseAttributes(saxNode.name, hdr, saxNode, SegmentType.Component)
-        this.segmentStack.push(segment)
+        if (hdr) {
+          const segment: SegmentDescription | null = this.parseAttributes(saxNode.name, hdr, saxNode, SegmentType.Component)
+          if (segment) {
+            this.segmentStack.push(segment)
+          }
+        }
         break
       }
 
@@ -177,71 +183,75 @@ export class FiXmlParser extends MsgParser {
     return new FixmlView(last, this.values, structure)
   }
 
-  private pop (name: string): SegmentDescription {
+  private pop (name: string): SegmentDescription | null {
     const locations = this.locations
     const stack = this.segmentStack
     const segments = this.segments
     while (stack.length > 0) {
       const pop = stack.pop()
       const ptr = locations.nextTagPos - 1
-      pop.end(segments.length, ptr, locations.tagPos[ptr].tag)
-      segments[segments.length] = pop
-      switch (pop.type) {
-        case SegmentType.Msg: {
-          // raise msg event
-          const last = segments[segments.length - 1]
-          this.last = last
-          this.emit('msg', last.name, this.getView())
-          if (this.raw) {
-            this.emit('decoded', this.last.name, this.raw)
-            this.raw = null
+      pop?.end(segments.length, ptr, locations.tagPos[ptr].tag)
+      if (pop) {
+        segments[segments.length] = pop
+        switch (pop.type) {
+          case SegmentType.Msg: {
+            // raise msg event
+            const last = segments[segments.length - 1]
+            this.last = last
+            this.emit('msg', last.name, this.getView())
+            if (this.raw) {
+              this.emit('decoded', this.last.name, this.raw)
+              this.raw = null
+            }
+            break
+          }
+          case SegmentType.Batch: {
+            const last = segments[segments.length - 1]
+            this.logger.debug(`emit batch with ${pop.delimiterPositions.length} elements`)
+            this.emit('batch', last?.set?.abbreviation, this.getView())
+            break
           }
-          break
         }
-        case SegmentType.Batch: {
-          const last = segments[segments.length - 1]
-          this.logger.debug(`emit batch with ${pop.delimiterPositions.length} elements`)
-          this.emit('batch', last.set.abbreviation, this.getView())
-          break
+        if (pop.name === name) {
+          return pop
         }
       }
-      if (pop.name === name) {
-        return pop
-      }
     }
     return null
   }
 
-  private startGroup (saxNode: ISaxNode, gf: ContainedGroupField) {
+  private startGroup (saxNode: ISaxNode, gf: ContainedGroupField): void {
     const locations = this.locations
     const stack: SegmentDescription[] = this.segmentStack
     const ptr = locations.nextTagPos
     const def = gf.definition
-    const segment: SegmentDescription = this.parseAttributes(saxNode.name, def, saxNode, SegmentType.Component)
-    const group: SegmentDescription = new SegmentDescription(def.name,
-      locations.tagPos[ptr].tag,
-      def,
-      ptr,
-      stack.length,
-      SegmentType.Group)
-    group.startGroup(locations.tagPos[ptr].tag)
-    group.addDelimiterPosition(ptr)
-    stack.push(group)
-    stack.push(segment)
+    const segment: SegmentDescription | null = this.parseAttributes(saxNode.name, def, saxNode, SegmentType.Component)
+    if (segment) {
+      const group: SegmentDescription = new SegmentDescription(def.name,
+        locations.tagPos[ptr].tag,
+        def,
+        ptr,
+        stack.length,
+        SegmentType.Group)
+      group.startGroup(locations.tagPos[ptr].tag)
+      group.addDelimiterPosition(ptr)
+      stack.push(group)
+      stack.push(segment)
+    }
   }
 
-  private getNextField (saxNode: ISaxNode): ContainedField {
+  private getNextField (saxNode: ISaxNode): ContainedField | null {
     const stack: SegmentDescription[] = this.segmentStack
     while (stack.length > 0) {
-      let peek: SegmentDescription = stack[stack.length - 1]
-      let field = peek.set.localNameToField.get(saxNode.name)
+      const peek: SegmentDescription = stack[stack.length - 1]
+      const field = peek?.set?.localNameToField.get(saxNode.name)
       if (field) {
         return field
       }
       // if this is a group of the same type as already on stack
       // take the field from the next level up
       if (peek.type === SegmentType.Group && stack.length > 1) {
-        const contained = stack[stack.length - 2].set.localNameToField.get(saxNode.name)
+        const contained = stack[stack.length - 2]?.set?.localNameToField.get(saxNode.name)
         if (contained instanceof ContainedGroupField) {
           if (contained.definition.name === peek.name) {
             // this is the same type for next instance in the same group.
@@ -254,18 +264,22 @@ export class FiXmlParser extends MsgParser {
       const ptr = locations.nextTagPos - 1
       const pop = stack.pop()
       const segments = this.segments
-      pop.end(segments.length, ptr, locations.tagPos[ptr].tag)
-      segments[segments.length] = pop
+      if (pop) {
+        pop.end(segments.length, ptr, locations.tagPos[ptr].tag)
+        segments[segments.length] = pop
+      }
     }
     return null
   }
 
-  private dispatch (saxNode: ISaxNode, field: ContainedField) {
+  private dispatch (saxNode: ISaxNode, field: ContainedField): void {
     switch (field.type) {
       case ContainedFieldType.Component: {
         const cf: ContainedComponentField = field as ContainedComponentField
-        const segment: SegmentDescription = this.parseAttributes(saxNode.name, cf.definition, saxNode, SegmentType.Component)
-        this.segmentStack.push(segment)
+        const segment: SegmentDescription | null = this.parseAttributes(saxNode.name, cf.definition, saxNode, SegmentType.Component)
+        if (segment) {
+          this.segmentStack.push(segment)
+        }
         break
       }
 
@@ -290,7 +304,10 @@ export class FiXmlParser extends MsgParser {
         if (gf.name === saxNode.name) {
           const ptr = this.locations.nextTagPos
           peek.addDelimiterPosition(ptr)
-          stack[stack.length] = this.parseAttributes(saxNode.name, gf.definition, saxNode, SegmentType.Component)
+          const a = this.parseAttributes(saxNode.name, gf.definition, saxNode, SegmentType.Component)
+          if (a) {
+            stack.push(a)
+          }
         } else {
           throw new Error(`expected another group instance of ${gf.name} but got ${saxNode.name}`)
         }
@@ -307,8 +324,8 @@ export class FiXmlParser extends MsgParser {
     const field = this.getNextField(saxNode)
     if (!field) {
       const stack: SegmentDescription[] = this.segmentStack
-      let peek: SegmentDescription = stack[stack.length - 1]
-      throw new Error(`field ${saxNode.name} not known in set ${peek.set.name}`)
+      const peek: SegmentDescription = stack[stack.length - 1]
+      throw new Error(`field ${saxNode.name} not known in set ${peek?.set?.name}`)
     }
     this.dispatch(saxNode, field)
   }
@@ -316,7 +333,7 @@ export class FiXmlParser extends MsgParser {
   private msg (saxNode: ISaxNode, inBatch: boolean = false): void {
     this.logger.debug(`${saxNode.name}: begin parse msg`)
     const type: string = saxNode.name
-    const def: MessageDefinition = this.definitions.message.get(type)
+    const def: MessageDefinition | null = this.definitions.message.get(type)
     if (!def) {
       throw new Error(`unknown message type ${type}`)
     }
@@ -324,11 +341,13 @@ export class FiXmlParser extends MsgParser {
       const batch = this.segmentStack[0]
       batch.set = def
     }
-    const segment: SegmentDescription = this.parseAttributes(type, def, saxNode, SegmentType.Msg)
-    this.segmentStack.push(segment)
+    const segment: SegmentDescription | null = this.parseAttributes(type, def, saxNode, SegmentType.Msg)
+    if (segment) {
+      this.segmentStack.push(segment)
+    }
   }
 
-  private parseAttributes (name: string, set: ContainedFieldSet, saxNode: ISaxNode, type: SegmentType): SegmentDescription {
+  private parseAttributes (name: string, set: ContainedFieldSet, saxNode: ISaxNode, type: SegmentType): SegmentDescription | null {
     const locations = this.locations
     const attributes = saxNode.attributes
     const values = this.values
@@ -350,5 +369,6 @@ export class FiXmlParser extends MsgParser {
       }
       return new SegmentDescription(name, locations.tagPos[ptr].tag, set, ptr, this.segmentStack.length, type)
     }
+    return null
   }
 }

package/src/buffer/fixml/fixml-view.ts

@@ -7,26 +7,25 @@ import * as moment from 'moment'
 import { TagType } from '../tag/tag-type'
 
 export class FixmlView extends MsgView {
-
   constructor (public readonly segment: SegmentDescription,
-               public readonly values: string[],
-               public readonly structure: Structure) {
+    public readonly values: string[],
+    public readonly structure: Structure) {
     super(segment, structure)
   }
 
   private static getTimestamp (s: string, useUtc: boolean): Date {
-    let m = moment(s)
+    const m = moment(s)
     return useUtc ? m.utc(true).toDate() : m.toDate()
   }
 
   // 01:00:08.201
   private static getTimeOnly (s: string, useUtc: boolean): Date {
-    let m = moment(s, [moment.HTML5_FMT.TIME_MS, moment.HTML5_FMT.TIME_SECONDS])
+    const m = moment(s, [moment.HTML5_FMT.TIME_MS, moment.HTML5_FMT.TIME_SECONDS])
     return useUtc ? m.utc(true).toDate() : m.toDate()
   }
 
   private static getDateOnly (s: string, useUtc: boolean): Date {
-    let m = moment(s)
+    const m = moment(s)
     let d: Date
     if (useUtc) {
       d = m.utc(true).toDate()
@@ -45,7 +44,7 @@ export class FixmlView extends MsgView {
     return 0
   }
 
-  protected create (singleton: SegmentDescription) {
+  protected create (singleton: SegmentDescription): FixmlView {
     return new FixmlView(singleton,
       this.values,
       this.structure)

package/src/buffer/fixml/populated-attributes.ts

@@ -1,6 +1,6 @@
 import { ContainedSimpleField } from '../../dictionary/contained'
 
 export interface IPopulatedAttributes {
-  fields: ContainedSimpleField[],
+  fields: ContainedSimpleField[]
   values: any[]
 }

package/src/buffer/msg-encoder.ts

@@ -9,7 +9,8 @@ export abstract class MsgEncoder extends events.EventEmitter {
   }
 
   public encode (o: ILooseObject, name: string): void {
-    const set: ContainedFieldSet = this.definitions.message.get(name) || this.definitions.component.get(name)
+    const set: ContainedFieldSet | null = this.definitions.message.get(name) ??
+      this.definitions.component.get(name)
     if (!set) {
       return
     }