jspurefix 3.4.0 → 4.0.0

package/src/buffer/msg-view.ts

@@ -1,19 +1,18 @@
 import { TagPos } from './tag/tag-pos'
 import { SegmentDescription } from './segment/segment-description'
 import { Structure } from './structure'
-import { Dictionary } from '../collections'
 import { Tags } from './tag/tags'
 import {
   ContainedComponentField,
   ContainedField,
-  ContainedFieldSet,
+  IContainedSet,
   ContainedGroupField,
   ContainedSimpleField
 } from '../dictionary/contained'
 import { SetReduce } from '../dictionary'
 import { ILooseObject } from '../collections/collection'
 import { ElasticBuffer } from './elastic-buffer'
-import { GroupFieldDefinition, SimpleFieldDefinition } from '../dictionary/definition'
+import { FixDefinitions, GroupFieldDefinition, SimpleFieldDefinition } from '../dictionary/definition'
 import { ITypeDispatcher } from '../dictionary/type-dispatcher'
 import { ContainedSetType } from '../dictionary/contained-set-type'
 
@@ -22,7 +21,7 @@ export abstract class MsgView {
   protected sortedTagPosBackwards: TagPos[]
   private readonly reducer: SetReduce<ILooseObject> = new SetReduce<ILooseObject>()
 
-  protected constructor (public readonly segment: SegmentDescription, public readonly structure: Structure | null) {
+  protected constructor (public readonly definitions: FixDefinitions, public readonly segment: SegmentDescription, public readonly structure: Structure | null) {
   }
 
   protected static asVerbose = (field: SimpleFieldDefinition, val: string, i: number, count: number, tp: TagPos): string => {
@@ -185,12 +184,12 @@ export abstract class MsgView {
    * returns typed value of a sinple field within this view
    * @param tagOrName the name or tag of required field e.g. 8, BeginString
    */
-  public getTyped (tagOrName: number | string): any {
+  public getTyped (tagOrName: number | string): (boolean | string | number | Date | Buffer | null) {
     const tag: number = this.resolveTag(tagOrName)
     if (tag == null) {
       return null
     }
-    const field: SimpleFieldDefinition | null = this.structure?.tags.definitions.tagToSimple[tag] ?? null
+    const field: SimpleFieldDefinition | null = this.definitions.tagToSimple[tag] ?? null
     if (field == null) {
       return null
     }
@@ -201,7 +200,7 @@ export abstract class MsgView {
    * use a varargs list of tags or tag names to fetch typed values for those fields within this view.
    * @param tagOrNames list of tags e.g. 'BeginString', 'BodyLength', ...
    */
-  public getTypedList (...tagOrNames: Array<number | string>): Array<boolean | string | number | Date | null> {
+  public getTypedList (...tagOrNames: Array<number | string>): Array<boolean | string | number | Date | Buffer | null> {
     return tagOrNames.map((s) => this.getTyped(s))
   }
 
@@ -209,7 +208,7 @@ export abstract class MsgView {
    * use an array of tags or tag names to fetch typed values for those fields within this view.
    * @param tagOrName the list of params as array ['BeginString','BodyLength', 'MsgType']
    */
-  public getTypedTags (tagOrName: Array<string | number>): Array<boolean | string | number | Date | null> {
+  public getTypedTags (tagOrName: Array<string | number>): Array<boolean | string | number | Date | Buffer | null> {
     return tagOrName.map((s) => this.getTyped(s))
   }
 
@@ -297,14 +296,15 @@ export abstract class MsgView {
 
   protected abstract stringAtPosition (position: number): string | null
 
-  protected abstract toTyped (field: SimpleFieldDefinition): boolean | string | number | Date
+  protected abstract toTyped (field: SimpleFieldDefinition): boolean | string | number | Date | Buffer | null
 
   protected resolveTag (tagOrName: number | string): number {
     let tag: number
+    const set = this.segment.set
     if (typeof (tagOrName) === 'string') {
-      if (this.segment.set == null) return 0
-      const cf = this.segment.set.simple.get(tagOrName)
-      const f: SimpleFieldDefinition | null = cf ? cf.definition : this.structure?.tags.definitions.simple.get(tagOrName) ?? null
+      if (set == null) return 0
+      const cf = set.simple.get(tagOrName)
+      const f: SimpleFieldDefinition | null = cf ? cf.definition : this.definitions.simple.get(tagOrName) ?? null
       if (f == null) {
         return -1
       }
@@ -382,7 +382,7 @@ export abstract class MsgView {
     return groupArray
   }
 
-  private asLoose (def: ContainedFieldSet): ILooseObject {
+  private asLoose (def: IContainedSet): ILooseObject {
     // eslint-disable-next-line
     return this.reducer.reduce(def, {
       group: (a: ILooseObject, field: ContainedGroupField) => { this.asLooseGroup(a, field) },
@@ -398,7 +398,7 @@ export abstract class MsgView {
     }, {}))
   }
 
-  private missingRequired (def: ContainedFieldSet, tags: number []): number[] {
+  private missingRequired (def: IContainedSet, tags: number []): number[] {
     const reducer = new SetReduce<number[]>()
     const dispatcher: ITypeDispatcher<number[]> = {
       group: (a: number[], field: ContainedGroupField) => { this.missingGroup(def, field, a) },
@@ -421,7 +421,7 @@ export abstract class MsgView {
     }
   }
 
-  private missingGroup (def: ContainedFieldSet, gf: ContainedGroupField, tags: number []): void {
+  private missingGroup (def: IContainedSet, gf: ContainedGroupField, tags: number []): void {
     const name = gf.definition.noOfField ? gf.definition.noOfField.name : def.name
     const groupView: MsgView | null = this.getView(name) ?? this.getView(gf.definition.name)
     if (groupView == null) {
@@ -448,7 +448,7 @@ export abstract class MsgView {
     const def = sf.definition
     const position: number = this.getPosition(def.tag)
     if (position >= 0) {
-      const asSimple: boolean | string | number | Date = this.toTyped(def)
+      const asSimple: boolean | string | number | Date | Buffer | null = this.toTyped(def)
       if (asSimple != null) { // beware, may be false value
         a[sf.name] = asSimple
       }
@@ -483,11 +483,11 @@ export abstract class MsgView {
     if (structure == null) return ''
     const tags: Tags = structure.tags
     const count: number = segment.endPosition - segment.startPosition
-    const simple: Dictionary<SimpleFieldDefinition> = tags.definitions.simple
+    const simple: Map<string, SimpleFieldDefinition> = this.definitions.simple
 
     for (let i: number = segment.startPosition; i <= segment.endPosition; ++i) {
       const tagPos: TagPos = tags.tagPos[i]
-      const field: SimpleFieldDefinition | null = simple.get(tagPos.tag.toString())
+      const field: SimpleFieldDefinition | undefined = simple.get(tagPos.tag.toString())
       const val: string | null = this.stringAtPosition(i) ?? ''
       // [0] 8 (BeginString) = FIX4.4
       const token = field ? getToken(field, val, i - segment.startPosition, count, tagPos) : `[${i}] ${tagPos.tag} (unknown) = ${val}, `

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

@@ -1,5 +1,5 @@
 import { INumericKeyed } from '../../collections/collection'
-import { ContainedField, ContainedFieldSet } from '../../dictionary/contained'
+import { ContainedField, IContainedSet } from '../../dictionary/contained'
 import { GroupFieldDefinition } from '../../dictionary/definition'
 import { SegmentType } from './segment-type'
 import { ElasticBuffer } from '../elastic-buffer'
@@ -16,7 +16,7 @@ export class SegmentDescription {
   constructor (
     public name: string,
     public startTag: number,
-    public set: ContainedFieldSet | null,
+    public set: IContainedSet | null,
     public startPosition: number,
     public readonly depth: number,
     public readonly type: SegmentType) {

package/src/buffer/tag/tags.ts

@@ -1,5 +1,3 @@
-import { FixDefinitions } from '../../dictionary/definition'
-import { ContainedSimpleField } from '../../dictionary/contained'
 import { TagPos } from './tag-pos'
 import { MsgTag } from '../../types'
 import { TagType } from './tag-type'
@@ -13,11 +11,11 @@ export class Tags {
   public tagPos: TagPos[] = new Array(this.startingLength)
   public nextTagPos: number = 0
 
-  constructor (public readonly definitions: FixDefinitions, public readonly startingLength: number = 30 * 1000) {
+  constructor (public readonly startingLength: number = 30 * 1000) {
   }
 
-  public static toJSType (simple: ContainedSimpleField): string {
-    switch (simple.definition.tagType) {
+  public static toJSType (tagType: TagType): string {
+    switch (tagType) {
       case TagType.String:
         return 'string'
 
@@ -103,7 +101,7 @@ export class Tags {
 
   public clone (): Tags {
     const next: number = this.nextTagPos
-    const cloned: Tags = new Tags(this.definitions, next)
+    const cloned: Tags = new Tags(next)
     cloned.nextTagPos = next
     for (let i = 0; i < next; ++i) {
       cloned.tagPos[i] = this.tagPos[i].clone()

package/src/collections/collection.ts

@@ -2,4 +2,3 @@ export type INumericKeyed<T> = Record<number, T>
 
 export type ILooseObject = Record<string, any>
 
-export type IDictIteratorCb<T> = (key: string, val: T) => void

package/src/collections/index.ts

@@ -1 +1 @@
-export * from './dictionary'
+

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

@@ -1,8 +1,9 @@
 import { FixDefinitions } from '../dictionary/definition'
-import { ISessionDescription, ISessionMsgFactory } from '../transport'
+import { ISessionDescription } from '../transport/session/session-description'
+import { ISessionMsgFactory } from '../transport/session/session-msg-factory'
 import { JsFixLoggerFactory } from './js-fix-logger-factory'
 import { EmptyLogFactory } from './empty-log-factory'
-import { AsciiChars } from '../buffer/ascii'
+import { AsciiChars } from '../buffer/ascii/ascii-chars'
 import { DependencyContainer } from 'tsyringe'
 
 export interface IJsFixConfig {

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

@@ -1,4 +1,10 @@
-import { ContainedField, ContainedFieldSet, ContainedGroupField, ContainedComponentField, ContainedFieldType } from '../contained'
+import {
+  ContainedField,
+  ContainedGroupField,
+  ContainedComponentField,
+  ContainedFieldType,
+  IContainedSet
+} from '../contained'
 import { FixDefinitions } from '../definition'
 
 import _ = require('lodash')
@@ -7,7 +13,7 @@ import { FixDefinitionSource } from '../fix-definition-source'
 
 export class CompilerType {
   public readonly snaked: string
-  constructor (public readonly definitions: FixDefinitions, public readonly set: ContainedFieldSet, public readonly qualifiedName: string) {
+  constructor (public readonly definitions: FixDefinitions, public readonly set: IContainedSet, public readonly qualifiedName: string) {
     const snake = _.snakeCase(this.qualifiedName)
     if (set.type === ContainedSetType.Msg) {
       this.snaked = `./${snake}`

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

@@ -73,7 +73,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[]) => {
+      return Array.from(field.enums.keys()).reduce((a: number, latest: string, i: number, arr: string[]) => {
         const k = field.resolveEnum(latest)
         let v: any = latest
         switch (field.tagType) {
@@ -120,7 +120,7 @@ export class EnumCompiler {
 
   private toDo (): SimpleFieldDefinition[] {
     const done: ILooseObject = {}
-    return this.definitions.simple.values().reduce((a: SimpleFieldDefinition[], latest: SimpleFieldDefinition) => {
+    return Array.from(this.definitions.simple.values()).reduce((a: SimpleFieldDefinition[], latest: SimpleFieldDefinition) => {
       if (latest.isEnum() && !done[latest.name]) {
         done[latest.name] = true
         a.push(latest)

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

@@ -4,14 +4,13 @@ import { ICompilerSettings } from './compiler-settings'
 import { FixDefinitions } from '../definition'
 import {
   ContainedComponentField,
-  ContainedFieldSet,
+  IContainedSet,
   ContainedGroupField,
   ContainedSimpleField,
   FieldsDispatch
 } from '../contained'
 import { StandardSnippet } from './standard-snippet'
 import { CompilerType } from './compiler-type'
-import { Dictionary } from '../../collections'
 
 import * as fs from 'fs'
 import * as Util from 'util'
@@ -20,22 +19,22 @@ import { SetReduce } from '../set-reduce'
 import { ContainedSetType } from '../contained-set-type'
 import { TagType } from '../../buffer/tag/tag-type'
 
-const newLine = require('os').EOL
+const newLine: string = require('os').EOL
 const justifiedWidth: number = 50
 
 export class MsgCompiler {
   readonly queue: CompilerType[] = []
   readonly snippets: StandardSnippet
   readonly buffer: ElasticBuffer = new ElasticBuffer()
-  readonly completed: Dictionary<CompilerType>
+  readonly completed: Map<string, CompilerType>
 
   constructor (public readonly definitions: FixDefinitions, public readonly settings: ICompilerSettings) {
-    this.completed = new Dictionary<CompilerType>()
+    this.completed = new Map<string, CompilerType>()
     this.snippets = new StandardSnippet(this.settings)
   }
 
   public async generate (): Promise<void> {
-    const types: string[] = this.settings.types ?? this.definitions.message.keys()
+    const types: string[] = this.settings.types ?? Array.from(this.definitions.message.keys())
     await this.createTypes(types)
   }
 
@@ -76,7 +75,7 @@ export class MsgCompiler {
     const writeFile = Util.promisify(fs.writeFile)
     const settings = this.settings
     const fileName = 'index.ts'
-    const done = this.completed.values()
+    const done = Array.from(this.completed.values())
     const exports: string[] = done.reduce<string[]>((prev: string[], current: CompilerType) => {
       prev.push(`export * from '${current.snaked}'`)
       return prev
@@ -126,7 +125,7 @@ export class MsgCompiler {
       return
     }
     this.queue.push(ct)
-    completed.addUpdate(fullName, ct)
+    completed.set(fullName, ct)
   }
 
   private simpleComment (simple: ContainedSimpleField): string {
@@ -137,7 +136,7 @@ export class MsgCompiler {
     const snippets = this.snippets
     const settings = this.settings
     const buffer = this.buffer
-    const len = buffer.writeString(snippets.simple(simple.name, Tags.toJSType(simple), simple.required, 1))
+    const len = buffer.writeString(snippets.simple(simple.name, Tags.toJSType(simple.definition.tagType), simple.required, 1))
     if (settings.tags) {
       buffer.writeString(snippets.commentLine(this.simpleComment(simple), justifiedWidth - len))
     }
@@ -155,7 +154,7 @@ export class MsgCompiler {
     buffer.writeString(newLine)
   }
 
-  private tagSummary (definition: ContainedFieldSet, max: number = 3): string {
+  private tagSummary (definition: IContainedSet, max: number = 3): string {
     function tagTxt (tag: number): string {
       const name = definition.getFieldName(tag)
       return `${name}.${tag}`
@@ -174,7 +173,7 @@ export class MsgCompiler {
     return `${front} .. ${tagTxt(flattened[flattened.length - 1])}`
   }
 
-  private setComment (set: ContainedFieldSet, position: number, len: number): void {
+  private setComment (set: IContainedSet, position: number, len: number): void {
     if (this.settings.tags) {
       const tagTxt = this.tagSummary(set)
       const buffer = this.buffer
@@ -206,7 +205,7 @@ export class MsgCompiler {
     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))
+      const len = buffer.writeString(snippets.simple(simple.definition.name, Tags.toJSType(simple.definition.tagType), simple.required, 1))
       if (settings.tags) {
         buffer.writeString(snippets.commentLine(this.simpleComment(simple), justifiedWidth - len))
       }

package/src/dictionary/contained/contained-component-field.ts

@@ -1,4 +1,4 @@
-import { ComponentFieldDefinition } from '../definition'
+import { ComponentFieldDefinition } from '../definition/component-field-definition'
 import { ContainedField } from './contained-field'
 import { ContainedFieldType } from './contained-field-type'
 

package/src/dictionary/contained/contained-field-set.ts

@@ -1,27 +1,23 @@
 import { INumericKeyed } from '../../collections/collection'
-import { Dictionary } from '../../collections'
-import { ContainedComponentField } from './contained-component-field'
 import { ContainedField } from './contained-field'
-import { ContainedGroupField } from './contained-group-field'
 import { ContainedSimpleField } from './contained-simple-field'
 import { ElasticBuffer } from '../../buffer/elastic-buffer'
-import { ContainedFieldType } from './contained-field-type'
-import { TagType } from '../../buffer/tag/tag-type'
 import { ContainedSetType } from '../contained-set-type'
+import { IContainedSet } from './contained-set'
 
-export abstract class ContainedFieldSet {
+export abstract class ContainedFieldSet implements IContainedSet {
   /**
    * index of name to any group that may be present within the field list
    */
-  public readonly groups: Dictionary<ContainedGroupField> = new Dictionary<ContainedGroupField>()
+  public readonly groups: Map<string, IContainedSet> = new Map<string, IContainedSet>()
   /**
    * index of name to any component that may be present within the field list
    */
-  public readonly components: Dictionary<ContainedComponentField> = new Dictionary<ContainedComponentField>()
+  public readonly components: Map<string, IContainedSet> = new Map<string, IContainedSet>()
   /**
    * index of name to any simple field that may be present within the field list
    */
-  public readonly simple: Dictionary<ContainedSimpleField> = new Dictionary<ContainedSimpleField>()
+  public readonly simple: Map<string, ContainedSimpleField> = new Map<string, ContainedSimpleField>()
   /**
    *  sequence of fields representing this type - can be simple, group or component
    */
@@ -57,11 +53,11 @@ export abstract class ContainedFieldSet {
   /**
    * only repository directly in this set indexed by name
    */
-  public readonly localNameToField: Dictionary<ContainedField> = new Dictionary<ContainedField>()
+  public readonly localNameToField: Map<string, ContainedField> = new Map<string, ContainedField>()
   /**
    * for FixMl notation this set of fields appear as attributes i.e. <Pty ID="323" R="38">
    */
-  public readonly nameToLocalAttribute: Dictionary<ContainedSimpleField> = new Dictionary<ContainedSimpleField>()
+  public readonly nameToLocalAttribute: Map<string, ContainedSimpleField> = new Map<string, ContainedSimpleField>()
   /**
    * all attributes in order of being declared
    */
@@ -114,187 +110,36 @@ export abstract class ContainedFieldSet {
 
   public abstract getPrefix (): string
 
+  public keys (): number[] {
+    const keys: string[] = Object.keys(this.containedTag)
+    const nums: number[] = new Array(keys.length)
+    for (let j: number = 0; j < keys.length; ++j) {
+      nums[j] = parseInt(keys[j], 10)
+    }
+    return nums
+  }
+
   public getFieldName (tag: number): string {
     const s = this.tagToSimple[tag]
     if (s == null) {
-      const gf = this.tagToField[tag] as ContainedGroupField
+      const gf: ContainedField = this.tagToField[tag]
       if (gf !== null) {
-        return `${gf.definition.name}`
+        return `${gf.name}`
       }
       return `${tag}`
     }
     return s.name
   }
 
-  /**
-   * adds a field to this set - simple, component or group
-   * @param field
-   */
-  public add (field: ContainedField): void {
-    this.fields.push(field)
-    this.localNameToField.addUpdate(field.name, field)
-    this.addUpdate(field)
-    this.addContained(this, field)
-  }
-
   /**
    * recurses down a path to return nested set definitiom of a group or component
    * given in dot notation 'SecListGrp.NoRelatedSym.SecurityTradingRules.BaseTradingRules'
    * @param path in dot notation
    */
-  public getSet (path: string): (ContainedFieldSet | null) {
+  public getSet (path: string): (IContainedSet | null) {
     if (!path) return null
-    return path.split('.').reduce((set: ContainedFieldSet, next: string): (ContainedFieldSet | null) => {
-      return set.groups.get(next)?.definition ?? set.components.get(next)?.definition ?? null
+    return path.split('.').reduce((set: IContainedSet, next: string): (IContainedSet | null) => {
+      return set.groups.get(next) ?? set.components.get(next) ?? null
     }, this)
   }
-
-  private addUpdate (field: ContainedField): void {
-    switch (field.type) {
-      case ContainedFieldType.Simple: {
-        this.addLocalSimple(field as ContainedSimpleField)
-        break
-      }
-
-      case ContainedFieldType.Component: {
-        const cf = field as ContainedComponentField
-        const definition = cf.definition
-        if (definition.abbreviation && definition.abbreviation !== field.name) {
-          this.localNameToField.addUpdate(definition.abbreviation, field)
-        }
-        break
-      }
-
-      case ContainedFieldType.Group: {
-        const gf = field as ContainedComponentField
-        const definition = gf.definition
-        if (definition.abbreviation && definition.abbreviation !== field.name) {
-          this.localNameToField.addUpdate(definition.abbreviation, field)
-        }
-        break
-      }
-
-      default:
-        throw new Error(`unknown field type ${field.type}`)
-    }
-  }
-
-  private addLocalSimple (field: ContainedSimpleField): void {
-    const definition = field.definition
-    if (definition.abbreviation && definition.abbreviation !== definition.name) {
-      this.localNameToField.addUpdate(definition.abbreviation, field)
-    }
-    if (definition.baseCategoryAbbreviation && definition.baseCategory === this.category) {
-      this.localNameToField.addUpdate(definition.baseCategoryAbbreviation, field)
-    }
-    if (field.attribute) {
-      this.nameToLocalAttribute.addUpdate(definition.abbreviation, field)
-      this.localAttribute.push(field)
-      // an attribute for FixMl lives in attribute set not fields - in this case xml sub elements
-      this.fields.pop()
-    }
-    const tag = definition.tag
-    this.localTag[tag] = field
-    if (field.required) {
-      this.localRequired[tag] = field
-    }
-  }
-
-  private addContained (parent: ContainedFieldSet, field: ContainedField): void {
-    switch (field.type) {
-      case ContainedFieldType.Group: {
-        this.addGroupFieldDef(field as ContainedGroupField)
-        break
-      }
-
-      case ContainedFieldType.Component: {
-        this.addComponentFieldDef(field as ContainedComponentField)
-        break
-      }
-
-      case ContainedFieldType.Simple: {
-        this.addSimpleFieldDef(parent, field as ContainedSimpleField)
-        break
-      }
-
-      default:
-        throw new Error(`unknown field type ${field.type}`)
-    }
-  }
-
-  private addAllFields (containedField: ContainedFieldSet): void {
-    containedField.fields.forEach((f: ContainedField) => {
-      this.addContained(containedField, f)
-    })
-  }
-
-  private addGroupFieldDef (groupField: ContainedGroupField): void {
-    if (this.groups.containsKey(groupField.name)) {
-      return
-    }
-    const definition = groupField.definition
-    this.groups.add(groupField.name, groupField)
-    const nof = definition.noOfField
-    if (nof) {
-      const tag = nof.tag
-      this.containedTag[tag] = true
-      this.flattenedTag.push(tag)
-    }
-    this.addAllFields(definition)
-    this.mapAllBelow(definition, groupField)
-  }
-
-  private addComponentFieldDef (componentField: ContainedComponentField): void {
-    const components = this.components
-    if (components.containsKey(componentField.name)) {
-      return
-    }
-    const definition = componentField.definition
-    components.add(componentField.name, componentField)
-    this.addAllFields(definition)
-    this.mapAllBelow(definition, componentField)
-  }
-
-  public keys (): number[] {
-    const keys: string[] = Object.keys(this.containedTag)
-    const nums: number[] = new Array(keys.length)
-    for (let j: number = 0; j < keys.length; ++j) {
-      nums[j] = parseInt(keys[j], 10)
-    }
-    return nums
-  }
-
-  private mapAllBelow (set: ContainedFieldSet, field: ContainedField): void {
-    // point all tags in this component to this field.
-    const tagsBelow: number[] = set.keys()
-    for (const t of tagsBelow) {
-      this.tagToField[t] = field
-    }
-  }
-
-  private addSimpleFieldDef (parent: ContainedFieldSet, field: ContainedSimpleField): void {
-    if (this.simple.containsKey(field.name)) {
-      return
-    }
-    if (!this.firstSimple) {
-      this.firstSimple = field
-    }
-    switch (field.definition.tagType) {
-      case TagType.RawData: {
-        const dataLengthField: ContainedSimpleField = parent.fields[field.position - 1] as ContainedSimpleField
-        if (dataLengthField && dataLengthField.definition.tagType === TagType.Length) {
-          this.containedLength[dataLengthField.definition.tag] = true
-          this.containsRaw = true
-        }
-        break
-      }
-      default:
-        break
-    }
-    const tag = field.definition.tag
-    this.simple.add(field.name, field)
-    this.containedTag[tag] = true
-    this.flattenedTag.push(tag)
-    this.tagToSimple[tag] = field
-  }
 }

package/src/dictionary/contained/contained-group-field.ts

@@ -1,5 +1,5 @@
 import { ContainedField } from './contained-field'
-import { GroupFieldDefinition } from '../definition'
+import { GroupFieldDefinition } from '../definition/group-field-definition'
 import { ContainedFieldType } from './contained-field-type'
 
 export class ContainedGroupField extends ContainedField {