jspurefix 2.2.0 → 3.0.0

package/src/buffer/segment/segment-description.ts

@@ -9,23 +9,23 @@ export class SegmentDescription {
   public endPosition: number = 0
   public delimiterTag: number = 0
   public delimiterPositions: number[]
-  public currentField: ContainedField
+  public currentField: ContainedField | null
   public containedDelimiterPositions: INumericKeyed<boolean>
 
   constructor (
-               public name: string,
-               public startTag: number,
-               public set: ContainedFieldSet,
-               public startPosition: number,
-               public readonly depth: number,
-               public readonly type: SegmentType) {
+    public name: string,
+    public startTag: number,
+    public set: ContainedFieldSet | null,
+    public startPosition: number,
+    public readonly depth: number,
+    public readonly type: SegmentType) {
   }
 
   public contains (segment: SegmentDescription): boolean {
     return segment.startPosition >= this.startPosition && segment.endPosition <= this.endPosition
   }
 
-  public getInstance (instance: number): SegmentDescription {
+  public getInstance (instance: number): SegmentDescription | null {
     const delimiters: number[] = this.delimiterPositions
     if (!delimiters) {
       return null
@@ -34,10 +34,10 @@ export class SegmentDescription {
       return null
     }
     const start: number = delimiters[instance]
-    const end: number = instance < delimiters.length - 1 ?
-            delimiters[instance + 1] - 1 :
-            this.endPosition
-    const name = this.type === SegmentType.Batch ? this.set.abbreviation : this.name
+    const end: number = instance < delimiters.length - 1
+      ? delimiters[instance + 1] - 1
+      : this.endPosition
+    const name: string = this.type === SegmentType.Batch ? this.set?.abbreviation ?? this.name : this.name ?? this.name ?? 'na'
     const d: SegmentDescription = new SegmentDescription(name, this.startTag, this.set, start, this.depth, this.type)
     d.endPosition = end
     d.endTag = this.endTag
@@ -60,7 +60,7 @@ export class SegmentDescription {
   }
 
   public setCurrentField (tag: number): void {
-    this.currentField = this.set.localTag[tag] || this.set.tagToField[tag]
+    this.currentField = this.set?.localTag[tag] ?? this.set?.tagToField[tag] ?? null
   }
 
   public groupAddDelimiter (tag: number, position: number): boolean {

package/src/buffer/segment/segment-summary.ts

@@ -11,8 +11,9 @@ export class SegmentSummary {
     public readonly delimiterTag: number,
     public readonly delimiterPositions: number[]) {
   }
+
   public static fromDescription (d: SegmentDescription): SegmentSummary {
-    return new SegmentSummary(d.set.name, d.depth, d.startTag, d.startPosition,
-            d.endTag, d.endPosition, d.delimiterTag, d.delimiterPositions || [])
+    return new SegmentSummary(d.set?.name ?? 'na', d.depth, d.startTag, d.startPosition,
+      d.endTag, d.endPosition, d.delimiterTag, d.delimiterPositions || [])
   }
 }

package/src/buffer/structure.ts

@@ -4,28 +4,28 @@ import { SegmentSummary } from './segment/segment-summary'
 import { Tags } from './tag/tags'
 
 export class Structure {
-  public readonly layout: ILooseObject = null
+  public readonly layout: ILooseObject
 
   constructor (public readonly tags: Tags,
-               public readonly segments: SegmentDescription[]) {
+    public readonly segments: SegmentDescription[]) {
     this.layout = this.boundLayout()
   }
 
   public msg (): SegmentDescription {
-        // trailer = -1, msg = -2
+    // trailer = -1, msg = -2
     return this.segments[this.segments.length - 2]
   }
 
   public summary (): SegmentSummary[] {
-    return this.segments.map(((s: SegmentDescription) => SegmentSummary.fromDescription(s)))
+    return this.segments.map((s: SegmentDescription) => SegmentSummary.fromDescription(s))
   }
 
-  public firstContainedWithin (name: string, segment: SegmentDescription): SegmentDescription {
+  public firstContainedWithin (name: string, segment: SegmentDescription): SegmentDescription | null {
     const all: SegmentDescription | SegmentDescription[] = this.layout[name]
     if (!all) {
       return null
     }
-    let ret: SegmentDescription = null
+    let ret: SegmentDescription | null = null
     if (!Array.isArray(all)) {
       const instance: SegmentDescription = all
       ret = segment.contains(instance) ? instance : null

package/src/buffer/time-format-template.ts

@@ -2,5 +2,5 @@ export abstract class TimeFormatTemplate {
   public static readonly DateYearMonthDay: string = 'YYYYMMDD'
   public static readonly TimeHourMinSecMilliColon: string = 'HH:mm:ss.SSS'
   public static readonly TimeHourMinSecColon: string = 'HH:mm:ss'
-  public static readonly DateYearMonthDayHyphen: string = 'YYYY-MM-DD'  // 2015-03-11
+  public static readonly DateYearMonthDayHyphen: string = 'YYYY-MM-DD' // 2015-03-11
 }

package/src/collections/collection.ts

@@ -1,9 +1,5 @@
-export interface INumericKeyed<T> {
-  [prop: number]: T
-}
+export type INumericKeyed<T> = Record<number, T>
 
-export interface ILooseObject {
-  [prop: string]: any
-}
+export type ILooseObject = Record<string, any>
 
 export type IDictIteratorCb<T> = (key: string, val: T) => void

package/src/collections/dictionary.ts

@@ -1,8 +1,7 @@
 import { IDictIteratorCb } from './collection'
 
 export class Dictionary<T> {
-
-  private container: { [id: string]: T; } = {}
+  private container: Record<string, T> = {}
 
   public count (): number {
     const keys: string[] = Object.keys(this.container)
@@ -23,7 +22,7 @@ export class Dictionary<T> {
   public toString (): string {
     return this.keys().reduce((a: string, current: string) => {
       const token = a.length > 0 ? ', ' : ''
-      return a + `${token}${this.container[current].toString() || ''}`
+      return a + `${token}${this.container[current]?.toString() ?? ''}`
     }, '')
   }
 
@@ -47,11 +46,11 @@ export class Dictionary<T> {
     delete this.container[key]
   }
 
-  public get (key: string): T {
+  public get (key: string): T | null {
     return this.container[key]
   }
 
-  public clear () {
+  public clear (): void {
     this.keys().forEach(k => {
       this.remove(k)
     })

package/src/config/empty-log-factory.ts

@@ -5,6 +5,7 @@ export class EmptyLogFactory extends JsFixLoggerFactory {
   public logger (type: string): IJsFixLogger {
     return new EmptyLogger(type)
   }
+
   public plain (fileName: string, maxSize?: number): IJsFixLogger {
     return new EmptyLogger()
   }

package/src/config/get-js-fx-logger.ts

@@ -1,4 +1,3 @@
 import { IJsFixLogger } from './js-fix-logger'
 
-export interface GetJsFixLogger { (type: string): IJsFixLogger
-}
+export type GetJsFixLogger = (type: string) => IJsFixLogger

package/src/config/js-fix-config.ts

@@ -6,7 +6,7 @@ import { AsciiChars } from '../buffer/ascii'
 import { DependencyContainer } from 'tsyringe'
 
 export interface IJsFixConfig {
-  factory: ISessionMsgFactory
+  factory: ISessionMsgFactory | null
   definitions: FixDefinitions
   description: ISessionDescription
   delimiter?: number
@@ -19,10 +19,10 @@ export class JsFixConfig implements IJsFixConfig {
   public logDelimiter: number = AsciiChars.Pipe
   public sessionContainer: DependencyContainer
   constructor (
-               public readonly factory: ISessionMsgFactory,
-               public readonly definitions: FixDefinitions,
-               public readonly description: ISessionDescription,
-               public readonly delimiter: number = AsciiChars.Soh,
-               public readonly logFactory: JsFixLoggerFactory = new EmptyLogFactory()) {
+    public readonly factory: ISessionMsgFactory | null,
+    public readonly definitions: FixDefinitions,
+    public readonly description: ISessionDescription,
+    public readonly delimiter: number = AsciiChars.Soh,
+    public readonly logFactory: JsFixLoggerFactory = new EmptyLogFactory()) {
   }
 }

package/src/config/js-fix-logger.ts

@@ -1,27 +1,32 @@
 export interface IJsFixLogger {
-  info (message: string): void
-  warning (message: string): void
-  debug (message: string): void
-  error (e: Error): void
+  info: (message: string) => void
+  warning: (message: string) => void
+  debug: (message: string) => void
+  error: (e: Error) => void
 }
 
 export class EmptyLogger implements IJsFixLogger {
   constructor (public readonly type: string = '') {
   }
-  public info (message: string) {
+
+  public info (message: string): void {
     // nothing
   }
-  public warning (message: string) {
+
+  public warning (message: string): void {
     // nothing
   }
-  public debug (message: string) {
+
+  public debug (message: string): void {
     // nothing
   }
-  public error (error: Error) {
+
+  // eslint-disable-next-line n/handle-callback-err
+  public error (error: Error): void {
     // nothing
   }
 }
 
-export function makeEmptyLogger (type: string) {
+export function makeEmptyLogger (type: string): IJsFixLogger {
   return new EmptyLogger(type)
 }

package/src/config/js-fix-winston-log-factory.ts

@@ -3,7 +3,7 @@ import { WinstonLogger } from './winston-logger'
 import { JsFixLoggerFactory } from './js-fix-logger-factory'
 
 export class JsFixWinstonLogFactory extends JsFixLoggerFactory {
-  private wl: WinstonLogger
+  private readonly wl: WinstonLogger
 
   constructor (public readonly options: any = WinstonLogger.consoleOptions()) {
     super()
@@ -13,6 +13,7 @@ export class JsFixWinstonLogFactory extends JsFixLoggerFactory {
   public logger (type: string): IJsFixLogger {
     return this.wl.make(type)
   }
+
   public plain (fileName: string, maxSize?: number): IJsFixLogger {
     return this.wl.plain(fileName, maxSize)
   }

package/src/config/winston-logger.ts

@@ -7,9 +7,11 @@ export class WinstonLogger {
   public static readonly appFormat = printf((info: any) => {
     return `${info.timestamp} [${info.type}] ${info.level}: ${info.message}`
   })
+
   public static readonly plainFormat = printf((info: any) => {
     return `${info.message}`
   })
+
   private readonly appLogger: Logger
 
   constructor (public readonly options: any = WinstonLogger.consoleOptions()) {
@@ -22,7 +24,7 @@ export class WinstonLogger {
         timestamp(),
         WinstonLogger.appFormat
       ),
-      level: level,
+      level,
       transports: [
         new transports.Console()
       ]
@@ -34,8 +36,8 @@ export class WinstonLogger {
     WinstonLogger.appFormat
   )): any {
     return {
-      format: format,
-      level: level,
+      format,
+      level,
       transports: [
         new transports.File({
           filename: fileName,
@@ -85,25 +87,25 @@ export class WinstonLogger {
     return {
       info: function (msg: string): void {
         logger.info({
-          type: type,
+          type,
           message: msg
         })
       },
       debug: function (msg: string): void {
         logger.debug({
-          type: type,
+          type,
           message: msg
         })
       },
       warning: function (msg: string): void {
         logger.warn({
-          type: type,
+          type,
           message: msg
         })
       },
       error: function (e: Error): void {
         logger.error({
-          type: type,
+          type,
           message: `${e.message} : ${e.stack}`
         })
       }

package/src/dictionary/compiler/compiler-settings.ts

@@ -1,8 +1,8 @@
 export interface ICompilerSettings {
-  standard: boolean,
-  spaces: number,
-  comment: boolean,
-  tags: true,
-  output: string,
+  standard: boolean
+  spaces: number
+  comment: boolean
+  tags: true
+  output: string
   types?: string[]
 }

package/src/dictionary/compiler/compiler-type.ts

@@ -51,7 +51,7 @@ export class CompilerType {
     }
   }
 
-  public getFieldGroupName (field: ContainedField) {
+  public getFieldGroupName (field: ContainedField): string {
     switch (field.type) {
       case ContainedFieldType.Group: {
         const gf = field as ContainedGroupField

package/src/dictionary/compiler/enum-compiler.ts

@@ -21,8 +21,8 @@ export class EnumCompiler {
 
   private static getIndex (): string {
     const lines = [
-      `export * from './all-enum'`,
-      `export * from './msg_tag'`,
+      'export * from \'./all-enum\'',
+      'export * from \'./msg_tag\'',
       ''
     ]
     return lines.join(require('os').EOL)
@@ -36,12 +36,11 @@ export class EnumCompiler {
 }
    */
 
-  public async generate (asOneFile: string = null) {
+  public async generate (asOneFile: string | null = null): Promise<void> {
     this.generateTagEnum('MsgTag').then(async () => {
       const toDo: SimpleFieldDefinition[] = this.toDo()
-      toDo.forEach(async (field: SimpleFieldDefinition) => {
-        await this.oneEnum(field, asOneFile)
-      })
+      const promised = toDo.map(async field => await this.oneEnum(field, asOneFile))
+      await Promise.all(promised)
       if (asOneFile) {
         await this.writeAsOne(asOneFile)
         await this.writeFile('index', EnumCompiler.getIndex())
@@ -51,7 +50,7 @@ export class EnumCompiler {
     })
   }
 
-  public async oneEnum (field: SimpleFieldDefinition, asOneFile: string) {
+  public async oneEnum (field: SimpleFieldDefinition, asOneFile: string | null): Promise<void> {
     const newLine = require('os').EOL
     const api = this.generateEnum(field)
     if (!asOneFile) {
@@ -75,7 +74,7 @@ export class EnumCompiler {
     return this.create(field.name, field.description, () => {
       const newLine = require('os').EOL
       return field.enums.keys().reduce((a: number, latest: string, i: number, arr: string[]) => {
-        let k = field.resolveEnum(latest)
+        const k = field.resolveEnum(latest)
         let v: any = latest
         switch (field.tagType) {
           case TagType.Int: {
@@ -94,7 +93,7 @@ export class EnumCompiler {
     })
   }
 
-  public async generateTagEnum (name: string) {
+  public async generateTagEnum (name: string): Promise<void> {
     const newLine = require('os').EOL
     const tags = this.definitions.tagToSimple
     const snippets = this.snippets
@@ -130,7 +129,7 @@ export class EnumCompiler {
     }, [])
   }
 
-  private async writeAsOne (asOneFile: string) {
+  private async writeAsOne (asOneFile: string): Promise<void> {
     const writer = util.promisify(fs.writeFile)
     await writer(asOneFile, this.consolidated.toString(), {
       encoding: 'utf8'
@@ -140,7 +139,7 @@ export class EnumCompiler {
     })
   }
 
-  private commentBlock (comment: string) {
+  private commentBlock (comment: string): void {
     const buffer = this.buffer
     const snippets = this.snippets
     const newLine = require('os').EOL
@@ -152,11 +151,10 @@ export class EnumCompiler {
     buffer.writeString(newLine)
   }
 
-  private async writeFile (name: string, api: string) {
+  private async writeFile (name: string, api: string): Promise<void> {
     const writer = util.promisify(fs.writeFile)
     const fullName = this.getFileName(name)
-    await writer(fullName, api, {
-      encoding: 'utf8'}
+    await writer(fullName, api, { encoding: 'utf8' }
     ).catch((e: Error) => {
       throw e
     })
@@ -166,11 +164,11 @@ export class EnumCompiler {
     const snake = _.snakeCase(name)
     const settings = this.settings
     const fileName = `${snake}.ts`
-    let path: string = `${settings.output}/enum/`
+    const path: string = `${settings.output}/enum/`
     return Path.join(path, fileName)
   }
 
-  private create (name: string, description: string, populateMembers: Function): string {
+  private create (name: string, description: string | null, populateMembers: Function): string {
     const newLine = require('os').EOL
     const buffer = this.buffer
     buffer.reset()

package/src/dictionary/compiler/msg-compiler.ts

@@ -2,7 +2,13 @@ import { ElasticBuffer, Tags } from '../../buffer'
 import { AsciiChars } from '../../buffer/ascii/'
 import { ICompilerSettings } from './compiler-settings'
 import { FixDefinitions } from '../definition'
-import { ContainedGroupField, ContainedSimpleField, ContainedComponentField, FieldsDispatch } from '../contained'
+import {
+  ContainedComponentField,
+  ContainedFieldSet,
+  ContainedGroupField,
+  ContainedSimpleField,
+  FieldsDispatch
+} from '../contained'
 import { StandardSnippet } from './standard-snippet'
 import { CompilerType } from './compiler-type'
 import { Dictionary } from '../../collections'
@@ -12,6 +18,10 @@ import * as Util from 'util'
 import * as Path from 'path'
 import { SetReduce } from '../set-reduce'
 import { ContainedSetType } from '../contained-set-type'
+import { TagType } from '../../buffer/tag/tag-type'
+
+const newLine = require('os').EOL
+const justifiedWidth: number = 50
 
 export class MsgCompiler {
   readonly queue: CompilerType[] = []
@@ -24,9 +34,9 @@ export class MsgCompiler {
     this.snippets = new StandardSnippet(this.settings)
   }
 
-  public async generate () {
-    const types: string[] = this.settings.types || this.definitions.message.keys()
-    return this.createTypes(types)
+  public async generate (): Promise<void> {
+    const types: string[] = this.settings.types ?? this.definitions.message.keys()
+    return await this.createTypes(types)
   }
 
   private getFileName (compilerType: CompilerType): string {
@@ -35,7 +45,7 @@ export class MsgCompiler {
     return Path.join(settings.output, fileName)
   }
 
-  private async createTypes (types: string[]) {
+  private async createTypes (types: string[]): Promise<void> {
     const definitions = this.definitions
     types.forEach((type: string) => {
       const definition = definitions.containedSet(type)
@@ -49,36 +59,33 @@ export class MsgCompiler {
     await this.index()
   }
 
-  private async work () {
+  private async work (): Promise<void> {
     const q = this.queue
     const writeFile = Util.promisify(fs.writeFile)
     while (q.length > 0) {
-      const compilerType: CompilerType = q.pop()
+      const compilerType = q.pop()
+      if (!compilerType) continue
       const api: string = this.generateMessages(compilerType)
       const fullName = this.getFileName(compilerType)
-      await writeFile(fullName, api, {
-        encoding: 'utf8'}
+      await writeFile(fullName, api, { encoding: 'utf8' }
       )
     }
   }
 
-  private async index () {
+  private async index (): Promise<void> {
     const writeFile = Util.promisify(fs.writeFile)
     const settings = this.settings
     const fileName = 'index.ts'
     const done = this.completed.values()
-    const exports: string[] = done.reduce((prev: string[], current: CompilerType) => {
+    const exports: string[] = done.reduce<string[]>((prev: string[], current: CompilerType) => {
       prev.push(`export * from '${current.snaked}'`)
       return prev
-    }, [`export * from './enum'`] as string[])
-    const newLine = require('os').EOL
+    }, ['export * from \'./enum\''])
     exports.sort()
     exports.push('')
     const api: string = exports.join(newLine)
     const fullName: string = Path.join(settings.output, fileName)
-    await writeFile(fullName, api, {
-      encoding: 'utf8'}
-    )
+    return await writeFile(fullName, api, { encoding: 'utf8' })
   }
 
   private generateMessages (compilerType: CompilerType): string {
@@ -86,9 +93,8 @@ export class MsgCompiler {
     const buffer: ElasticBuffer = this.buffer
     buffer.reset()
     const snippets = this.snippets
-    const newLine = require('os').EOL
     // a single class with dependencies included
-    let ptr: number = this.imports(compilerType)
+    const ptr: number = this.imports(compilerType)
     if (ptr > 0) {
       buffer.writeString(newLine)
       buffer.writeString(newLine)
@@ -127,32 +133,58 @@ export class MsgCompiler {
     const snippets = this.snippets
     const settings = this.settings
     const buffer = this.buffer
-    const newLine = require('os').EOL
     const len = buffer.writeString(snippets.simple(simple.name, Tags.toJSType(simple), simple.required, 1))
     if (settings.tags) {
-      buffer.writeString(snippets.commentLine(`${simple.definition.tag}`, 50 - len))
+      buffer.writeString(snippets.commentLine(`[${simple.position + 1}] ${simple.definition.tag} (${TagType[simple.definition.tagType]})`, justifiedWidth - len))
     }
     buffer.writeString(newLine)
   }
 
   private fieldGroup (groupField: ContainedGroupField, compilerType: CompilerType): void {
-    const newLine = require('os').EOL
     const buffer = this.buffer
     const snippets = this.snippets
     // for a group its field name is as defined in type, its type is qualified to avoid collisions
     const extended: string = compilerType.getExtended(groupField)
-    buffer.writeString(snippets.group(compilerType.getFieldGroupName(groupField), extended, groupField.required, 1))
+    const len = buffer.writeString(snippets.group(compilerType.getFieldGroupName(groupField), extended, groupField.required, 1))
+    this.setComment(groupField.definition, groupField.position, len)
     this.enqueue(new CompilerType(this.definitions, groupField.definition, extended))
     buffer.writeString(newLine)
   }
 
+  private tagSummary (definition: ContainedFieldSet, max: number = 3): string {
+    function tagTxt (tag: number): string {
+      const name = definition.getFieldName(tag)
+      return `${name}.${tag}`
+    }
+
+    function setTxt (flattened: number[]): string {
+      return flattened.map(f => tagTxt(f)).join(', ')
+    }
+
+    const flattened = definition.flattenedTag
+    if (max >= flattened.length) {
+      return setTxt(flattened)
+    }
+
+    const front = setTxt(flattened.slice(0, max - 1))
+    return `${front} .. ${tagTxt(flattened[flattened.length - 1])}`
+  }
+
+  private setComment (set: ContainedFieldSet, position: number, len: number): void {
+    if (this.settings.tags) {
+      const tagTxt = this.tagSummary(set)
+      const buffer = this.buffer
+      buffer.writeString(this.snippets.commentLine(`[${position + 1}] ${tagTxt}`, justifiedWidth - len))
+    }
+  }
+
   private fieldComponent (componentField: ContainedComponentField, compilerType: CompilerType): void {
-    const newLine = require('os').EOL
     const buffer = this.buffer
     const snippets = this.snippets
     const extended: string = compilerType.getExtended(componentField)
-    buffer.writeString(snippets.component(extended, componentField.required, 1))
+    const len = buffer.writeString(snippets.component(extended, componentField.required, 1))
     this.enqueue(new CompilerType(this.definitions, componentField.definition, extended))
+    this.setComment(componentField.definition, componentField.position, len)
     buffer.writeString(newLine)
   }
 
@@ -167,13 +199,12 @@ export class MsgCompiler {
 
   private attributes (compilerType: CompilerType): void {
     const settings = this.settings
-    const newLine = require('os').EOL
     const snippets = this.snippets
     const buffer = this.buffer
     compilerType.set.localAttribute.forEach((simple: ContainedSimpleField) => {
       const len = buffer.writeString(snippets.simple(simple.definition.name, Tags.toJSType(simple), simple.required, 1))
       if (settings.tags) {
-        buffer.writeString(snippets.commentLine(`${simple.definition.tag}`, 50 - len))
+        buffer.writeString(snippets.commentLine(`${simple.definition.tag}`, justifiedWidth - len))
       }
       buffer.writeString(newLine)
     })
@@ -194,6 +225,6 @@ export class MsgCompiler {
       }
     }, [])
 
-    return this.buffer.writeString(imports.join(require('os').EOL))
+    return this.buffer.writeString(imports.join(newLine))
   }
 }