jspurefix 3.4.0 → 4.0.0

package/src/dictionary/parser/fix-repository/repository.ts

@@ -3,8 +3,14 @@ import {
   SimpleFieldDefinition, GroupFieldDefinition, ComponentFieldDefinition,
   MessageDefinition, FixDefinitions
 } from '../../definition'
-import { Dictionary } from '../../../collections'
-import { ContainedFieldSet, ContainedComponentField, ContainedGroupField, ContainedSimpleField } from '../../contained'
+
+import {
+  IContainedSet,
+  ContainedComponentField,
+  ContainedGroupField,
+  ContainedSimpleField,
+  ContainedSetBuilder
+} from '../../contained'
 import { FixVersion } from '../../fix-versions'
 import { GetJsFixLogger, IJsFixLogger } from '../../../config'
 import { FixDefinitionSource } from '../../fix-definition-source'
@@ -28,10 +34,10 @@ export class Repository {
   public includesAbbreviations: boolean
   // derived from above
   public readonly definitions: FixDefinitions
-  private readonly groupLookup: Dictionary<GroupFieldDefinition> = new Dictionary<GroupFieldDefinition>()
-  private contentLookup: Dictionary<IRepositoryMsgContent[]>
-  private componentLookup: Dictionary<IRepositoryComponent>
-  private dataTypeLookup: Dictionary<IRepositoryDataType>
+  private readonly groupLookup: Map<string, GroupFieldDefinition> = new Map<string, GroupFieldDefinition>()
+  private contentLookup: Map<string, IRepositoryMsgContent[]>
+  private componentLookup: Map<string, IRepositoryComponent>
+  private dataTypeLookup: Map<string, IRepositoryDataType>
   private readonly logger: IJsFixLogger
 
   constructor (public readonly version: FixVersion, public readonly getLogger: GetJsFixLogger) {
@@ -104,9 +110,9 @@ export class Repository {
   private summarise (): void {
     const logger = this.logger
     const definitions = this.definitions
-    logger.info(`definitions: ${definitions.simple.count()} fields`)
-    logger.info(`definitions: ${definitions.component.count()} components`)
-    logger.info(`definitions: ${definitions.message.count()} messages`)
+    logger.info(`definitions: ${definitions.simple.size} fields`)
+    logger.info(`definitions: ${definitions.component.size} components`)
+    logger.info(`definitions: ${definitions.message.size} messages`)
   }
 
   private toDefinitions (): void {
@@ -129,16 +135,16 @@ export class Repository {
   }
 
   private header (): void {
-    const h: ComponentFieldDefinition | null = this.definitions.component.get('StandardHeader')
+    const h: ComponentFieldDefinition | undefined = this.definitions.component.get('StandardHeader')
     if (h) {
-      this.definitions.component.add('header', h)
+      this.definitions.component.set('header', h)
     }
   }
 
   private trailer (): void {
-    const t: ComponentFieldDefinition | null = this.definitions.component.get('StandardTrailer')
+    const t: ComponentFieldDefinition | undefined = this.definitions.component.get('StandardTrailer')
     if (t) {
-      this.definitions.component.add('trailer', t)
+      this.definitions.component.set('trailer', t)
     }
   }
 
@@ -189,8 +195,8 @@ export class Repository {
     this.dataTypeLookup = this.types()
     const definitions = this.definitions
     const types = this.dataTypeLookup
-    types.remove('boolean')
-    types.remove('data')
+    types.delete('boolean')
+    types.delete('data')
     this.Fields.forEach((f: IRepositoryField) => {
       const type = this.getType(f)
       definitions.addSimpleFieldDef(Repository.makeSimple(f, type))
@@ -198,32 +204,33 @@ export class Repository {
     this.fieldEnums()
   }
 
-  private contents (): Dictionary<IRepositoryMsgContent[]> {
+  private contents (): Map<string, IRepositoryMsgContent[]> {
     return this.MsgContents.reduce((a, current) => {
-      let content: IRepositoryMsgContent[] | null = a.get(current.ComponentID)
+      let content: IRepositoryMsgContent[] | undefined = a.get(current.ComponentID)
       if (!content) {
         content = []
-        a.add(current.ComponentID, content)
+        a.set(current.ComponentID, content)
       }
       content[content.length] = current
       return a
-    }, new Dictionary<IRepositoryMsgContent[]>())
+    }, new Map<string, IRepositoryMsgContent[]>())
   }
 
-  private resolveToFieldSet (content: IRepositoryMsgContent[], parentSet: ContainedFieldSet): void {
+  private resolveToFieldSet (content: IRepositoryMsgContent[], parentSet: IContainedSet): void {
+    const builder = new ContainedSetBuilder(parentSet)
     content.forEach((current: IRepositoryMsgContent) => {
       const required: boolean = current.Reqd === '1'
       const tag: number = parseInt(current.TagText, 10)
       if (!isNaN(tag)) {
         const sf: SimpleFieldDefinition = this.definitions.tagToSimple[tag]
         if (sf) {
-          parentSet.add(new ContainedSimpleField(sf, parentSet.fields.length, required, false))
+          builder.add(new ContainedSimpleField(sf, parentSet.fields.length, required, false))
         }
       } else {
         // is there a definition for this type yet create.
-        let childSet: ContainedFieldSet | null = this.definitions.component.get(current.TagText)
+        let childSet: IContainedSet | undefined = this.definitions.component.get(current.TagText)
         if (!childSet) {
-          const cl: IRepositoryComponent | null = this.componentLookup.get(current.TagText)
+          const cl: IRepositoryComponent | undefined = this.componentLookup.get(current.TagText)
           if (cl) {
             childSet = this.resolve(cl)
           }
@@ -231,12 +238,12 @@ export class Repository {
         if (childSet) {
           switch (childSet.type) {
             case ContainedSetType.Component: {
-              parentSet.add(new ContainedComponentField(childSet as ComponentFieldDefinition, parentSet.fields.length, required))
+              builder.add(new ContainedComponentField(childSet as ComponentFieldDefinition, parentSet.fields.length, required))
               break
             }
 
             case ContainedSetType.Group: {
-              parentSet.add(new ContainedGroupField(childSet as GroupFieldDefinition, parentSet.fields.length, required))
+              builder.add(new ContainedGroupField(childSet as GroupFieldDefinition, parentSet.fields.length, required))
               break
             }
 
@@ -250,24 +257,24 @@ export class Repository {
     })
   }
 
-  private resolve (c: IRepositoryComponent): ContainedFieldSet {
+  private resolve (c: IRepositoryComponent): IContainedSet {
     switch (c.ComponentType) {
       case 'ImplicitBlockRepeating':
       case 'BlockRepeating': {
-        const content: IRepositoryMsgContent[] | null = this.contentLookup.get(c.ComponentID) ?? []
+        const content: IRepositoryMsgContent[] | undefined = this.contentLookup.get(c.ComponentID) ?? []
         const noField: SimpleFieldDefinition = this.definitions.tagToSimple[parseInt(content[0].TagText, 10)]
-        let def: GroupFieldDefinition | null = this.groupLookup.get(c.ComponentID)
+        let def: GroupFieldDefinition | undefined = this.groupLookup.get(c.ComponentID)
         if (!def) {
           def = new GroupFieldDefinition(c.Name, c.AbbrName, c.CategoryID, noField, c.Description)
           this.resolveToFieldSet(content.slice(1), def)
-          this.groupLookup.add(c.ComponentID, def)
+          this.groupLookup.set(c.ComponentID, def)
         }
         return def
       }
 
       default: {
         const content: IRepositoryMsgContent[] | null = this.contentLookup.get(c.ComponentID) ?? []
-        let def: ComponentFieldDefinition | null = this.definitions.component.get(c.Name)
+        let def: ComponentFieldDefinition | undefined = this.definitions.component.get(c.Name)
         if (!def) {
           def = new ComponentFieldDefinition(c.Name, c.AbbrName, c.CategoryID, c.Description)
           this.resolveToFieldSet(content, def)
@@ -281,7 +288,7 @@ export class Repository {
   private message (m: IRepositoryMessage): MessageDefinition {
     const definitions = this.definitions
     const content: IRepositoryMsgContent[] = this.contentLookup.get(m.ComponentID) ?? []
-    let def: MessageDefinition | null = definitions.message.get(m.Name)
+    let def: MessageDefinition | undefined = definitions.message.get(m.Name)
     if (!def) {
       def = new MessageDefinition(m.Name, m.AbbrName, m.MsgType, m.CategoryID, m.Description)
       this.resolveToFieldSet(content, def)
@@ -290,18 +297,18 @@ export class Repository {
     return def
   }
 
-  private components (): Dictionary<IRepositoryComponent> {
-    return this.Components.reduce((a: Dictionary<IRepositoryComponent>, current: IRepositoryComponent) => {
-      a.add(current.Name, current)
-      a.add(current.ComponentID, current)
+  private components (): Map<string, IRepositoryComponent> {
+    return this.Components.reduce((a: Map<string, IRepositoryComponent>, current: IRepositoryComponent) => {
+      a.set(current.Name, current)
+      a.set(current.ComponentID, current)
       return a
-    }, new Dictionary<IRepositoryComponent>())
+    }, new Map<string, IRepositoryComponent>())
   }
 
-  private types (): Dictionary<IRepositoryDataType> {
-    return this.DataTypes.reduce((a: Dictionary<IRepositoryDataType>, current: IRepositoryDataType) => {
-      a.add(current.Name, current)
+  private types (): Map<string, IRepositoryDataType> {
+    return this.DataTypes.reduce((a: Map<string, IRepositoryDataType>, current: IRepositoryDataType) => {
+      a.set(current.Name, current)
       return a
-    }, new Dictionary<IRepositoryDataType>())
+    }, new Map<string, IRepositoryDataType>())
   }
 }

package/src/dictionary/parser/fixml/components-parser.ts

@@ -1,9 +1,9 @@
 import { ISaxNode } from '../../sax-node'
-import { Dictionary } from '../../../collections'
 import { XsdParser } from './xsd-parser'
 import {
   ContainedGroupField,
-  ContainedFieldSet,
+  IContainedSet,
+  ContainedSetBuilder,
   ContainedComponentField,
   ContainedSimpleField,
   ContainedField
@@ -16,10 +16,10 @@ import {
 } from '../../definition'
 
 export class ComponentsParser extends XsdParser {
-  private readonly attributeGroups: Dictionary<IAttributeGroup> = new Dictionary<IAttributeGroup>()
-  private readonly groups: Dictionary<IGroup> = new Dictionary<IGroup>()
+  private readonly attributeGroups: Map<string, IAttributeGroup> = new Map<string, IAttributeGroup>()
+  private readonly groups: Map<string, IGroup> = new Map<string, IGroup>()
   private readonly unboundElements: IElement[] = []
-  private readonly complexTypes: Dictionary<IComplexType> = new Dictionary<IComplexType>()
+  private readonly complexTypes: Map<string, IComplexType> = new Map<string, IComplexType>()
 
   private newComplexTypes: IComplexType[]
   private currentGroup: (IGroup | null)
@@ -31,7 +31,7 @@ export class ComponentsParser extends XsdParser {
     super(definitions)
   }
 
-  private static getName (group: (IGroup | null), attributeGroup: (IAttributeGroup | null), type: IComplexType): string {
+  private static getName (group: (IGroup | undefined), attributeGroup: (IAttributeGroup | undefined), type: IComplexType): string {
     let name: string
     if (type?.appInfo) {
       name = type.appInfo.name
@@ -64,7 +64,7 @@ export class ComponentsParser extends XsdParser {
         if (this.currentComplexType != null) {
           const complex: IComplexType = this.currentComplexType
           this.previousComplexType = complex
-          this.complexTypes.addUpdate(complex.name, complex)
+          this.complexTypes.set(complex.name, complex)
           this.newComplexTypes.push(complex)
           this.currentComplexType = null
         }
@@ -73,7 +73,7 @@ export class ComponentsParser extends XsdParser {
 
       case 'xs:group': {
         if (this.currentGroup) {
-          this.groups.addUpdate(this.currentGroup.name, this.currentGroup)
+          this.groups.set(this.currentGroup.name, this.currentGroup)
           this.currentGroup = null
         }
         break
@@ -84,7 +84,7 @@ export class ComponentsParser extends XsdParser {
         if (attributeStack.length > 0) {
           const group: IAttributeGroup | undefined = attributeStack.pop()
           if (group?.name) {
-            this.attributeGroups.addUpdate(group?.name, group)
+            this.attributeGroups.set(group?.name, group)
           }
         }
         break
@@ -242,12 +242,13 @@ export class ComponentsParser extends XsdParser {
     }
   }
 
-  private addElement (set: ContainedFieldSet, element: IElement): void {
+  private addElement (set: IContainedSet, element: IElement): void {
     const minOccurs: number = parseInt(element.minOccurs, 10)
     const isGroup: boolean = element.maxOccurs === 'unbounded'
     const isComponent: boolean = element.maxOccurs === '1' || !isGroup
     const key = element.type || element.ref || element.name
-    const containedType: IComplexType | null = this.complexTypes.get(key)
+    const builder = new ContainedSetBuilder(set)
+    const containedType: IComplexType | undefined = this.complexTypes.get(key)
     if (containedType) {
       if (isComponent) {
         const containedDefinition: ComponentFieldDefinition = this.getComponent(containedType)
@@ -256,7 +257,7 @@ export class ComponentsParser extends XsdParser {
             set.fields.length,
             minOccurs > 0,
             element.name)
-        set.add(containedField)
+        builder.add(containedField)
       } else if (isGroup) {
         const containedDefinition: GroupFieldDefinition = this.getGroup(containedType)
         const containedField: ContainedGroupField =
@@ -264,7 +265,7 @@ export class ComponentsParser extends XsdParser {
             set.fields.length,
             minOccurs > 0,
             element.name)
-        set.add(containedField)
+        builder.add(containedField)
       }
     } else {
       if (key !== 'Message') {
@@ -273,12 +274,12 @@ export class ComponentsParser extends XsdParser {
     }
   }
 
-  private addElements (set: ContainedFieldSet, elements: IElement[]): void {
+  private addElements (set: IContainedSet, elements: IElement[]): void {
     if (elements) {
       elements.forEach((element: IElement) => {
         switch (element.type) {
           case 'xs:group': {
-            const groupElements: IGroup | null = this.groups.get(element.name)
+            const groupElements: IGroup | undefined = this.groups.get(element.name)
             if (groupElements) {
               this.addElements(set, groupElements.elements)
             } else {
@@ -295,7 +296,7 @@ export class ComponentsParser extends XsdParser {
     }
   }
 
-  private addSimpleAttribute (set: ContainedFieldSet, attribute: IAttribute): void {
+  private addSimpleAttribute (set: IContainedSet, attribute: IAttribute): void {
     let sf = this.definitions.getSimple(attribute.type)
     if (!sf) {
       sf = this.definitions.getSimple(attribute.name, set.category)
@@ -306,17 +307,18 @@ export class ComponentsParser extends XsdParser {
         attribute.use !== 'optional',
         true,
         attribute.name)
-      set.add(contained)
+      const builder = new ContainedSetBuilder(set)
+      builder.add(contained)
     } else if (set.name !== 'FixmlAttributes') {
       throw new Error(`unable to resolve simple attribute ${attribute.name}`)
     }
   }
 
-  private addAttributes (set: ContainedFieldSet, attributes: IAttribute[]): void {
+  private addAttributes (set: IContainedSet, attributes: IAttribute[]): void {
     attributes.forEach((attribute: IAttribute) => {
       switch (attribute.type) {
         case 'xs:attributeGroup': {
-          const attributeGroup: IAttributeGroup | null = this.attributeGroups.get(attribute.name)
+          const attributeGroup: IAttributeGroup | undefined = this.attributeGroups.get(attribute.name)
           if (attributeGroup) {
             this.addAttributes(set, attributeGroup.attributes)
           } else {
@@ -333,8 +335,8 @@ export class ComponentsParser extends XsdParser {
   }
 
   private getGroup (type: IComplexType): GroupFieldDefinition {
-    const group: IGroup | null = this.groups.get(type.group)
-    const attributeGroup: IAttributeGroup | null = this.attributeGroups.get(type.attributeGroup)
+    const group: IGroup | undefined = this.groups.get(type.group)
+    const attributeGroup: IAttributeGroup | undefined = this.attributeGroups.get(type.attributeGroup)
     const name: string = ComponentsParser.getName(group, attributeGroup, type)
     const category = type.appInfo != null ? type.appInfo.Category : null
     const groupDefinition: GroupFieldDefinition = new GroupFieldDefinition(name, name, category, null, null)
@@ -344,25 +346,25 @@ export class ComponentsParser extends XsdParser {
 
   private getComponent (type: IComplexType): ComponentFieldDefinition {
     const definitions: FixDefinitions = this.definitions
-    const group: IGroup | null = this.groups.get(type.group)
-    const attributeGroup: IAttributeGroup | null = this.attributeGroups.get(type.attributeGroup)
+    const group: IGroup | undefined = this.groups.get(type.group)
+    const attributeGroup: IAttributeGroup | undefined = this.attributeGroups.get(type.attributeGroup)
     let name: string = ComponentsParser.getName(group, attributeGroup, type)
-    const cached: ComponentFieldDefinition | null = definitions.component.get(name)
+    const cached: ComponentFieldDefinition | undefined = definitions.component.get(name)
     if (cached) {
       return cached
     }
 
     const category = type.appInfo != null ? type.appInfo.Category : null
     if (type.extensionBase) {
-      const base: IComplexType | null = this.complexTypes.get(type.extensionBase)
+      const base: IComplexType | undefined = this.complexTypes.get(type.extensionBase)
       if (base) {
         name = base.appInfo.name
       }
     }
     const component: ComponentFieldDefinition = new ComponentFieldDefinition(name, name, category, null)
     this.populateSet(type, component)
-    definitions.component.addUpdate(component.name, component)
-    definitions.component.addUpdate(type.name, component)
+    definitions.component.set(component.name, component)
+    definitions.component.set(type.name, component)
     return component
   }
 
@@ -375,24 +377,25 @@ export class ComponentsParser extends XsdParser {
       type.appInfo.MsgID,
       type.appInfo.Category,
       type.annotation.documentation)
-    const abstractMessage: ComponentFieldDefinition | null = definitions.component.get('Message')
+    const builder = new ContainedSetBuilder(message)
+    const abstractMessage: ComponentFieldDefinition | undefined = definitions.component.get('Message')
     abstractMessage?.fields.forEach((f: ContainedField) => {
-      message.add(f)
+      builder.add(f)
     })
     this.populateSet(type, message)
-    messages.addUpdate(message.name, message)
+    messages.set(message.name, message)
     if (type.messageName && type.messageName !== name) {
-      messages.addUpdate(type.messageName, message)
+      messages.set(type.messageName, message)
     }
 
     return message
   }
 
   private getBaseAttributes (type: IComplexType): (IAttributeGroup | null) {
-    const attributeGroups: Dictionary<IAttributeGroup> = this.attributeGroups
+    const attributeGroups: Map<string, IAttributeGroup> = this.attributeGroups
     let baseGroup
     if (type.extensionBase) {
-      const base: IComplexType | null = this.complexTypes.get(type.extensionBase)
+      const base: IComplexType | undefined = this.complexTypes.get(type.extensionBase)
       if (base) {
         baseGroup = attributeGroups.get(base.attributeGroup)
       }
@@ -401,11 +404,11 @@ export class ComponentsParser extends XsdParser {
     return null
   }
 
-  private populateSet (type: IComplexType, set: ContainedFieldSet): void {
-    const group: IGroup | null = this.groups.get(type.group)
+  private populateSet (type: IComplexType, set: IContainedSet): void {
+    const group: IGroup | undefined = this.groups.get(type.group)
     const elements: IElement[] = group ? group.elements : type.element
     const attributeGroups = this.attributeGroups
-    const attributeGroup: IAttributeGroup | null = attributeGroups.get(type.attributeGroup)
+    const attributeGroup: IAttributeGroup | undefined = attributeGroups.get(type.attributeGroup)
     const baseGroup: IAttributeGroup | null = this.getBaseAttributes(type)
     // if a base is specified add the attributes from there
     if (baseGroup) {
@@ -455,9 +458,9 @@ export class ComponentsParser extends XsdParser {
     })
     this.unboundElements.forEach((e: IElement) => {
       const definitions = this.definitions
-      const component: ComponentFieldDefinition | null = definitions.component.get(e.type)
+      const component: ComponentFieldDefinition | undefined = definitions.component.get(e.type)
       if (component) {
-        definitions.component.addUpdate(e.name, component)
+        definitions.component.set(e.name, component)
       }
     })
   }

package/src/dictionary/parser/fixml/fields-parser.ts

@@ -1,5 +1,4 @@
 import { ILooseObject } from '../../../collections/collection'
-import { Dictionary } from '../../../collections'
 import { SimpleFieldDefinition, FixDefinitions } from '../../definition'
 import { XsdParser } from './xsd-parser'
 import { ISaxNode } from '../../sax-node'
@@ -16,7 +15,7 @@ interface ISimpleField extends ILooseObject {
   AbbrName: string
   Category: string
   CategoryAbbrName: string
-  enums: Dictionary<string>
+  enums: Map<string, string>
   currentEnum: string
 }
 
@@ -35,7 +34,7 @@ export class FieldsParser extends XsdParser {
     const current: ISimpleField = this.current as ISimpleField
     switch (n) {
       case 'fm:EnumDoc': {
-        current.enums.add(current.currentEnum, v)
+        current.enums.set(current.currentEnum, v)
         break
       }
       case 'xs:documentation': {
@@ -81,7 +80,7 @@ export class FieldsParser extends XsdParser {
 
       case 'fm:EnumDoc': {
         if (!this.current.enums) {
-          this.current.enums = new Dictionary<string>()
+          this.current.enums = new Map<string, string>()
         }
         this.current.currentEnum = node.attributes.value
         this.pending = node.name

package/src/dictionary/parser/fixml/include-graph.ts

@@ -1,5 +1,4 @@
 import { SAXStream } from '../../dict-primitive'
-import { Dictionary } from '../../../collections'
 import { INumericKeyed } from '../../../collections/collection'
 import * as path from 'path'
 import * as fs from 'fs'
@@ -21,7 +20,7 @@ export interface IGraphNode {
  */
 
 export class IncludeGraph {
-  private nodes: Dictionary<number>
+  private nodes: Map<string, number>
   private includes: IInclude[]
   private graph: INumericKeyed<IGraphNode>
   constructor (public readonly root: string, public readonly main: string) {
@@ -34,7 +33,7 @@ export class IncludeGraph {
   }
 
   public resolve (file: string): string[] | null {
-    const label: number | null = this.nodes.get(file)
+    const label: number | undefined = this.nodes.get(file)
     if (label == null) {
       return null
     }
@@ -60,7 +59,7 @@ export class IncludeGraph {
   private getGraph (): void {
     const nodes = this.nodes
     this.graph = this.includes.reduce<INumericKeyed<IGraphNode>>((a: INumericKeyed<IGraphNode>, current: IInclude) => {
-      const parent: number | null = nodes.get(current.parent)
+      const parent: number | undefined = nodes.get(current.parent)
       if (parent == null) return a
       let parentNode = a[parent]
       if (!parentNode) {
@@ -71,7 +70,7 @@ export class IncludeGraph {
         } as IGraphNode
       }
       current.children.forEach((s: string) => {
-        const child: number | null = nodes.get(s)
+        const child: number | undefined = nodes.get(s)
         if (child) {
           if (!parentNode.edges.includes(child)) {
             parentNode.edges.push(child)
@@ -84,17 +83,17 @@ export class IncludeGraph {
 
   private assignNodes (): void {
     let next: number = 0
-    this.nodes = this.includes.reduce((a: Dictionary<number>, current: IInclude) => {
-      if (!a.containsKey(current.parent)) {
-        a.add(current.parent, next++)
+    this.nodes = this.includes.reduce((a: Map<string, number>, current: IInclude) => {
+      if (!a.has(current.parent)) {
+        a.set(current.parent, next++)
       }
       current.children.forEach((c: string) => {
-        if (!a.containsKey(c)) {
-          a.add(c, next++)
+        if (!a.has(c)) {
+          a.set(c, next++)
         }
       })
       return a
-    }, new Dictionary<number>())
+    }, new Map<string, number>())
   }
 
   private async scanIncludes (file: string): Promise<string[]> {
@@ -125,16 +124,16 @@ export class IncludeGraph {
     const q: any[] = []
     q.push([main])
     const ordered: IInclude[] = []
-    const seen: Dictionary<boolean> = new Dictionary<boolean>()
+    const seen: Map<string, boolean> = new Map<string, boolean>()
     return await new Promise<IInclude[]>(async (resolve, reject) => {
       try {
         while (q.length > 0) {
           const batch: string[] = q.pop()
           for (const next of batch) {
-            if (seen.containsKey(next)) {
+            if (seen.has(next)) {
               continue
             }
-            seen.add(next, true)
+            seen.set(next, true)
             const includes: string[] = await this.scanIncludes(next)
             ordered.push({
               parent: next,

package/src/dictionary/parser/quickfix/field-definition-parser.ts

@@ -13,12 +13,12 @@ export class FieldDefinitionParser extends NodeParser {
     switch (node.name) {
       case 'field': {
         this.currentField = new SimpleFieldDefinition(
-          node.attributes.number,
-          node.attributes.name,
-          node.attributes.name,
+          node.attributes.number as string,
+          node.attributes.name as string,
+          node.attributes.name as string,
           null,
           null,
-          node.attributes.type,
+          node.attributes.type as string,
           null)
         this.progress.newDefines++
         this.progress.definitions.addSimpleFieldDef(this.currentField)
@@ -26,7 +26,7 @@ export class FieldDefinitionParser extends NodeParser {
       }
 
       case 'value': {
-        this.currentField.addEnum(node.attributes.enum, node.attributes.description)
+        this.currentField.addEnum(node.attributes.enum as string, node.attributes.description as string)
         break
       }
     }

package/src/dictionary/parser/quickfix/message-parser.ts

@@ -1,9 +1,10 @@
 import { MessageDefinition } from '../../definition'
 import { NodeParser } from './node-parser'
 import { ParseContext } from './parse-context'
-import { ContainedComponentField } from '../../contained'
+import { ContainedComponentField, ContainedSetBuilder } from '../../contained'
 import { ISaxNode } from '../../sax-node'
 import { ParseProgress } from './parse-progress'
+import { ILooseObject } from '../../../collections/collection'
 
 export class MessageParser extends NodeParser {
   constructor (protected readonly progress: ParseProgress) {
@@ -13,8 +14,8 @@ export class MessageParser extends NodeParser {
   public open (line: number, node: ISaxNode): void {
     switch (node.name) {
       case 'message': {
-        const att: any = node.attributes
-        const msg: MessageDefinition = new MessageDefinition(att.name, att.name, att.msgtype, att.msgcat, null)
+        const att: ILooseObject = node.attributes
+        const msg: MessageDefinition = new MessageDefinition(att.name as string, att.name as string, att.msgtype as string, att.msgcat as string, null)
         const context: ParseContext = new ParseContext(msg.name, true, msg)
         this.header(msg, context)
         break
@@ -27,7 +28,7 @@ export class MessageParser extends NodeParser {
 
       case 'component': {
         if (node.isSelfClosing) {
-          this.addComponentField(node.attributes.name, node)
+          this.addComponentField(node.attributes.name as string, node)
         }
         break
       }
@@ -43,12 +44,13 @@ export class MessageParser extends NodeParser {
 
   private header (msg: MessageDefinition, context: ParseContext): void {
     const hdr = this.progress.definitions.component.get('StandardHeader')
+    const builder = new ContainedSetBuilder(msg)
     const contained = hdr
       ? new ContainedComponentField(hdr, msg.fields.length, true)
       : null
     if (contained) {
       this.progress.newAdds++
-      msg.add(contained)
+      builder.add(contained)
       this.startContext(context)
     }
   }