jspurefix 1.2.0 → 2.0.0

package/src/buffer/ascii/ascii-segment-parser.ts

@@ -1,21 +1,27 @@
+import { SegmentDescription } from '../segment/segment-description'
+import { Structure } from '../structure'
+import { Tags } from '../tag/tags'
+import {
+  FixDefinitions,
+  MessageDefinition
+} from '../../dictionary/definition'
 import {
   ContainedComponentField,
-  ContainedFieldType,
   ContainedGroupField,
   ContainedSimpleField,
-  FixDefinitions,
-  MessageDefinition
-} from '../..'
-import { SegmentDescription, SegmentType } from '../segment-description'
-import { Structure } from '../structure'
-import { Tags } from '../tags'
+  ContainedFieldType
+} from '../../dictionary/contained'
+import { inject, injectable } from 'tsyringe'
+import { DITokens } from '../../runtime/di-tokens'
+import { SegmentType } from '../segment/segment-type'
 
 // this takes linear time i.e. it constantly makes forward progress
 // one tag at a time
 
+@injectable()
 export class AsciiSegmentParser {
 
-  constructor (public readonly definitions: FixDefinitions) {
+  constructor (@inject(DITokens.Definitions) public readonly definitions: FixDefinitions) {
   }
 
   public parse (msgType: string, tags: Tags, last: number): Structure {

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

@@ -1,14 +1,13 @@
-import { SimpleFieldDefinition } from '../../dictionary'
-import { SegmentDescription } from '../segment-description'
+import { SimpleFieldDefinition } from '../../dictionary/definition'
+import { SegmentDescription } from '../segment/segment-description'
 import { Structure } from '../structure'
-import { TagType } from '../tags'
 import { MsgView } from '../msg-view'
 import { ElasticBuffer } from '../elastic-buffer'
 import { ITimeFormatter } from './itime-formatter'
 import { TimeFormatter } from './time-formatter'
-import { TagPos } from '../tag-pos'
+import { TagPos } from '../tag/tag-pos'
 import { MsgTag } from '../../types'
-import { FixMsgStoreRecord } from '../../store'
+import { TagType } from '../tag/tag-type'
 
 export class AsciiView extends MsgView {
   private readonly timeFormatter: ITimeFormatter = new TimeFormatter(this.buffer)
@@ -35,10 +34,6 @@ export class AsciiView extends MsgView {
     return new AsciiView(segment, buffer, null, this.ptr, delimiter, writeDelimiter)
   }
 
-  public toMsgStoreRecord () {
-    return new FixMsgStoreRecord(this.getString(MsgTag.MsgType), this.getTyped(MsgTag.SendingTime), this.getTyped(MsgTag.MsgSeqNum), this.toObject())
-  }
-
   public checksum (): number {
     const t = this.getPosition(MsgTag.CheckSum)
     const structure = this.structure

package/src/buffer/ascii/index.ts

@@ -1,3 +1,4 @@
+export * from './ascii-chars'
 export * from './ascii-encoder'
 export * from './ascii-parser'
 export * from './ascii-parser-state'

package/src/buffer/ascii/parse-state.ts

@@ -0,0 +1,8 @@
+export enum ParseState {
+  BeginField = 1,
+  ParsingTag = 2,
+  ParsingValue = 3,
+  ParsingRawDataLength = 4,
+  ParsingRawData = 5,
+  MsgComplete = 6
+}

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

@@ -1,4 +1,4 @@
-import { AsciiChars } from '../ascii-chars'
+import { AsciiChars } from './ascii-chars'
 import { ElasticBuffer } from '../elastic-buffer'
 import { ITimeFormatter } from './itime-formatter'
 
@@ -23,13 +23,13 @@ export class TimeFormatter implements ITimeFormatter {
   public writeUtcTimestamp (v: Date): void {
     this.writeUtcDate(v)
     this.buffer.writeChar(AsciiChars.Hyphen)
-    this.writeUtcTime(v as Date)
+    this.writeUtcTime(v)
   }
 
   public writeLocalTimestamp (v: Date): void {
     this.writeLocalDate(v)
     this.buffer.writeChar(AsciiChars.Hyphen)
-    this.writeLocalTime(v as Date)
+    this.writeLocalTime(v)
   }
 
   public writeUtcTime (v: Date): void {

package/src/buffer/elastic-buffer.ts

@@ -1,12 +1,17 @@
-import { AsciiChars } from './ascii-chars'
+import { AsciiChars } from './ascii/ascii-chars'
 import { format } from 'mathjs'
+import { inject, injectable } from 'tsyringe'
+import { DITokens } from '../runtime/di-tokens'
 
+@injectable()
 export class ElasticBuffer {
   private buffer: Buffer
   private ptr: number = 0
   private stretched: number
 
-  constructor (public readonly size: number = 6 * 1024, public readonly returnTo: number = 6 * 1024) {
+  constructor (@inject(DITokens.elasticBufferSize) public readonly size: 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)

package/src/buffer/encode-proxy.ts

@@ -1,14 +1,19 @@
-import { FixDefinitions, MessageDefinition, SimpleFieldDefinition, ContainedField, ContainedFieldType, ContainedSimpleField, ContainedComponentField, ContainedGroupField, ContainedFieldSet } from '..'
 import { ILooseObject } from '../collections/collection'
-import { TagType } from './tags'
+import { FixDefinitions, MessageDefinition, SimpleFieldDefinition } from '../dictionary/definition'
+import {
+  ContainedComponentField, ContainedField,
+  ContainedFieldSet, ContainedFieldType,
+  ContainedGroupField,
+  ContainedSimpleField
+} from '../dictionary/contained'
+import { TagType } from './tag/tag-type'
 
 export class EncodeProxy {
   constructor (public readonly definitions: FixDefinitions) {
   }
 
   private static SimpleFieldCheck (field: ContainedSimpleField, val: any): void {
-    const sf: ContainedSimpleField = field as ContainedSimpleField
-    const definition: SimpleFieldDefinition = sf.definition
+    const definition: SimpleFieldDefinition = field.definition
     if (definition.isEnum()) {
       const resolved: boolean = definition.containsEnum(val)
       if (!resolved) {
@@ -73,7 +78,7 @@ export class EncodeProxy {
     if (!isComplex) {
       throw new Error(`type ${field.name} is a component but is given type "${typeof val}"`)
     }
-    const cf: ContainedComponentField = field as ContainedComponentField
+    const cf: ContainedComponentField = field
     return EncodeProxy.checkProperties(new Proxy({}, EncodeProxy.handler(cf.definition)), val)
   }
 

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

@@ -1,16 +1,20 @@
 import { ILooseObject } from '../../collections/collection'
-import { ContainedFieldSet, ContainedField, ContainedGroupField, ContainedComponentField, ContainedSimpleField, FixDefinitions, dispatchFields, IFieldDispatcher } from '../../dictionary'
-import { AsciiChars } from '../ascii-chars'
-import { TagType } from '../tags'
+import {
+  ContainedFieldSet, ContainedField, ContainedGroupField,
+  ContainedComponentField, ContainedSimpleField, FieldsDispatch
+} from '../../dictionary/contained'
+import { AsciiChars } from '../ascii'
 import { MsgEncoder } from '../msg-encoder'
 import { ElasticBuffer } from '../elastic-buffer'
 import moment = require('moment')
-
-interface IPopulatedAttributes {
-  fields: ContainedSimpleField[],
-  values: any[]
-}
-
+import { FixDefinitions } from '../../dictionary/definition'
+import { IFieldDispatcher } from '../../dictionary/contained/field-dispatcher'
+import { TagType } from '../tag/tag-type'
+import { IPopulatedAttributes } from './populated-attributes'
+import { inject, injectable } from 'tsyringe'
+import { DITokens } from '../../runtime/di-tokens'
+
+@injectable()
 export class FixmlEncoder extends MsgEncoder {
   public attributePerLine: boolean = false
   public readonly eol: string = require('os').EOL
@@ -19,7 +23,7 @@ export class FixmlEncoder extends MsgEncoder {
   private readonly beginBatch: string = `<Batch>${this.eol}`
   private readonly endBatch: string = '</Batch>'
 
-  public constructor (public readonly buffer: ElasticBuffer, public readonly definitions: FixDefinitions) {
+  public constructor (@inject(DITokens.TransmitBuffer) public readonly buffer: ElasticBuffer, @inject(DITokens.Definitions) public readonly definitions: FixDefinitions) {
     super(definitions)
   }
 
@@ -114,7 +118,7 @@ export class FixmlEncoder extends MsgEncoder {
     buffer.writeString(`${name} `)
     this.attributes(o, set, depth, this.attributePerLine)
     buffer.writeString(`${eol}`)
-    dispatchFields(fields, {
+    new FieldsDispatch().dispatchFields(fields, {
       group: (g: ContainedGroupField) => this.complexGroup(o, g, depth),
       component: (c: ContainedComponentField) => this.complexComponent(o, c, depth)
     } as IFieldDispatcher)

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

@@ -1,13 +1,22 @@
 import { MsgParser } from '../msg-parser'
-import { Tags } from '../tags'
-import { ContainedField, ContainedFieldType, ContainedComponentField, ContainedGroupField, ContainedSimpleField, ContainedFieldSet, ISaxNode, SAXStream, FixDefinitions, MessageDefinition } from '../../dictionary'
-import { SegmentDescription, SegmentType } from '../segment-description'
+import { Tags } from '../tag/tags'
+import { SAXStream } from '../../dictionary'
+import { FixDefinitions, MessageDefinition } from '../../dictionary/definition'
+import { ContainedField, ContainedComponentField,
+  ContainedFieldType, ContainedGroupField,
+  ContainedSimpleField, ContainedFieldSet } from '../../dictionary/contained'
+import { SegmentDescription } from '../segment/segment-description'
 import { IJsFixConfig, IJsFixLogger } from '../../config'
 import { MsgView } from '../msg-view'
 import { Structure } from '../structure'
 import { FixmlView } from './fixml-view'
 import { Readable } from 'stream'
+import { inject, injectable } from 'tsyringe'
+import { DITokens } from '../../runtime/di-tokens'
+import { ISaxNode } from '../../dictionary/sax-node'
+import { SegmentType } from '../segment/segment-type'
 
+@injectable()
 export class FiXmlParser extends MsgParser {
   private readonly locations: Tags
   private values: string[] = []
@@ -18,9 +27,10 @@ export class FiXmlParser extends MsgParser {
   private readonly logger: IJsFixLogger
   private last: SegmentDescription
   private raw: string
-  constructor (public readonly config: IJsFixConfig,
-               public readonly readStream: Readable,
-               public readonly maxMessageLocations: number = 10 * 1024) {
+
+  constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig,
+               @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

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

@@ -1,10 +1,10 @@
 import { MsgView } from '../msg-view'
-import { SimpleFieldDefinition } from '../../dictionary'
+import { SimpleFieldDefinition } from '../../dictionary/definition'
 import { Structure } from '../structure'
-import { SegmentDescription } from '../segment-description'
-import { TagType } from '../tags'
-import { AsciiChars } from '../ascii-chars'
+import { SegmentDescription } from '../segment/segment-description'
+import { AsciiChars } from '../ascii/'
 import * as moment from 'moment'
+import { TagType } from '../tag/tag-type'
 
 export class FixmlView extends MsgView {
 

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

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

package/src/buffer/index.ts

@@ -1,15 +1,11 @@
-export * from './ascii/ascii-encoder'
-export * from './ascii'
-export * from './fixml'
-export * from './ascii-chars'
 export * from './elastic-buffer'
 export * from './encode-proxy'
 export * from './encoder-state'
 export * from './msg-encoder'
 export * from './msg-parser'
 export * from './msg-view'
-export * from './segment-description'
-export * from './segment-summary'
+export * from './segment/segment-description'
+export * from './segment/segment-summary'
 export * from './structure'
-export * from './tag-pos'
-export * from './tags'
+export * from './tag/tag-pos'
+export * from './tag/tags'

package/src/buffer/msg-encoder.ts

@@ -1,5 +1,6 @@
 import { ILooseObject } from '../collections/collection'
-import { ContainedFieldSet, FixDefinitions } from '../dictionary'
+import { FixDefinitions } from '../dictionary/definition'
+import { ContainedFieldSet } from '../dictionary/contained'
 import * as events from 'events'
 
 export abstract class MsgEncoder extends events.EventEmitter {

package/src/buffer/msg-view.ts

@@ -1,11 +1,16 @@
-import { TagPos } from './tag-pos'
-import { SegmentDescription } from './segment-description'
+import { TagPos } from './tag/tag-pos'
+import { SegmentDescription } from './segment/segment-description'
 import { Structure } from './structure'
 import { Dictionary } from '../collections'
-import { Tags } from './tags'
-import { ContainedGroupField, ContainedComponentField, ContainedField, ContainedFieldSet, ContainedSimpleField, SimpleFieldDefinition, GroupFieldDefinition, ITypeDispatcher, reduceSet, ContainedSetType } from '../dictionary'
+import { Tags } from './tag/tags'
+import { ContainedGroupField, ContainedComponentField, ContainedField,
+  ContainedFieldSet, 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 { ITypeDispatcher } from '../dictionary/type-dispatcher'
+import { ContainedSetType } from '../dictionary/contained-set-type'
 
 export abstract class MsgView {
   protected sortedTagPosForwards: TagPos[]
@@ -307,7 +312,8 @@ export abstract class MsgView {
   }
 
   private asLoose (def: ContainedFieldSet): ILooseObject {
-    return reduceSet<ILooseObject>(def, {
+    const reducer = new SetReduce<ILooseObject>()
+    return reducer.reduce(def, {
       group: (a: ILooseObject, field: ContainedGroupField) => this.asLooseGroup(a, field),
       simple: (a: ILooseObject, field: ContainedSimpleField) => this.asLooseSimple(a, field),
       component: (a: ILooseObject, field: ContainedComponentField) => this.asLooseComponent(a, field)
@@ -322,7 +328,8 @@ export abstract class MsgView {
   }
 
   private missingRequired (def: ContainedFieldSet, tags: number []): number[] {
-    return reduceSet<number[]>(def, {
+    const reducer = new SetReduce<number[]>()
+    return reducer.reduce(def, {
       group: (a: number[], field: ContainedGroupField) => this.missingGroup(def, field, a),
       simple: (a: number[], field: ContainedSimpleField) => this.missingSimple(field, a),
       component: (a: number[], field: ContainedComponentField) => this.missingComponent(field, a)

package/src/buffer/{segment-description.ts → segment/segment-description.ts}

@@ -1,14 +1,7 @@
-import { INumericKeyed } from '../collections/collection'
-import { ContainedField, ContainedFieldSet, GroupFieldDefinition } from '../dictionary'
-
-export enum SegmentType {
-    Component = 0,
-    Group = 1,
-    Msg = 2,
-    Gap = 3,
-    Batch = 4,
-    Unknown = 5
-}
+import { INumericKeyed } from '../../collections/collection'
+import { ContainedField, ContainedFieldSet } from '../../dictionary/contained'
+import { GroupFieldDefinition } from '../../dictionary/definition'
+import { SegmentType } from './segment-type'
 
 export class SegmentDescription {
   public index: number

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

@@ -0,0 +1,8 @@
+export enum SegmentType {
+  Component = 0,
+  Group = 1,
+  Msg = 2,
+  Gap = 3,
+  Batch = 4,
+  Unknown = 5
+}

package/src/buffer/structure.ts

@@ -1,7 +1,7 @@
 import { ILooseObject } from '../collections/collection'
-import { SegmentDescription } from './segment-description'
-import { SegmentSummary } from './segment-summary'
-import { Tags } from './tags'
+import { SegmentDescription } from './segment/segment-description'
+import { SegmentSummary } from './segment/segment-summary'
+import { Tags } from './tag/tags'
 
 export class Structure {
   public readonly layout: ILooseObject = null

package/src/buffer/tag/tag-type.ts

@@ -0,0 +1,13 @@
+export enum TagType {
+  String = 1,
+  Int = 2,
+  Float = 3,
+  Boolean = 4,
+  UtcTimestamp = 5,
+  UtcDateOnly = 6,
+  UtcTimeOnly = 7,
+  LocalDate = 8,
+  RawData = 9,
+  Length = 10,
+  Unknown = 11
+}

package/src/buffer/{tags.ts → tag/tags.ts}

@@ -1,20 +1,8 @@
-import { FixDefinitions, ContainedSimpleField } from '../dictionary'
+import { FixDefinitions } from '../../dictionary/definition'
+import { ContainedSimpleField } from '../../dictionary/contained'
 import { TagPos } from './tag-pos'
-import { MsgTag } from '../types'
-
-export enum TagType {
-    String = 1,
-    Int = 2,
-    Float = 3,
-    Boolean = 4,
-    UtcTimestamp = 5,
-    UtcDateOnly = 6,
-    UtcTimeOnly = 7,
-    LocalDate = 8,
-    RawData = 9,
-    Length = 10,
-    Unknown = 11
-}
+import { MsgTag } from '../../types'
+import { TagType } from './tag-type'
 
 export class Tags {
   public static readonly BeginString: number = MsgTag.BeginString

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

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

package/src/config/index.ts

@@ -1,5 +1,6 @@
 export * from './empty-log-factory'
 export * from './js-fix-config'
+export * from './get-js-fx-logger'
 export * from './js-fix-logger'
 export * from './js-fix-logger-factory'
 export * from './js-fix-winston-log-factory'

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

@@ -1,8 +1,9 @@
-import { FixDefinitions } from '../dictionary'
+import { FixDefinitions } from '../dictionary/definition'
 import { ISessionDescription, ISessionMsgFactory } from '../transport'
 import { JsFixLoggerFactory } from './js-fix-logger-factory'
 import { EmptyLogFactory } from './empty-log-factory'
-import { AsciiChars } from '../buffer'
+import { AsciiChars } from '../buffer/ascii'
+import { DependencyContainer } from 'tsyringe'
 
 export interface IJsFixConfig {
   factory: ISessionMsgFactory
@@ -11,10 +12,12 @@ export interface IJsFixConfig {
   delimiter?: number
   logDelimiter?: number
   logFactory: JsFixLoggerFactory
+  sessionContainer: DependencyContainer
 }
 
 export class JsFixConfig implements IJsFixConfig {
   public logDelimiter: number = AsciiChars.Pipe
+  public sessionContainer: DependencyContainer
   constructor (
                public readonly factory: ISessionMsgFactory,
                public readonly definitions: FixDefinitions,

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

@@ -5,9 +5,6 @@ export interface IJsFixLogger {
   error (e: Error): void
 }
 
-export interface GetJsFixLogger { (type: string): IJsFixLogger
-}
-
 export class EmptyLogger implements IJsFixLogger {
   constructor (public readonly type: string = '') {
   }

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

@@ -1,9 +1,9 @@
-import { ContainedField, ContainedFieldType, ContainedFieldSet, ContainedGroupField, ContainedComponentField } from '../contained'
+import { ContainedField, ContainedFieldSet, ContainedGroupField, ContainedComponentField, ContainedFieldType } from '../contained'
 import { FixDefinitions } from '../definition'
-import { FixDefinitionSource } from '../fix-versions'
-import { ContainedSetType } from '../dict-primitive'
 
 import _ = require('lodash')
+import { ContainedSetType } from '../contained-set-type'
+import { FixDefinitionSource } from '../fix-definition-source'
 
 export class CompilerType {
   public readonly snaked: string

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

@@ -1,13 +1,14 @@
 import { FixDefinitions, SimpleFieldDefinition } from '../definition'
 import { ICompilerSettings } from './compiler-settings'
 import { StandardSnippet } from './standard-snippet'
-import { TagType, ElasticBuffer } from '../../buffer'
+import { ElasticBuffer } from '../../buffer'
 import { ILooseObject } from '../../collections/collection'
 
 import * as fs from 'fs'
 import * as util from 'util'
 import * as Path from 'path'
 import * as _ from 'lodash'
+import { TagType } from '../../buffer/tag/tag-type'
 
 export class EnumCompiler {
   private readonly buffer: ElasticBuffer = new ElasticBuffer()
@@ -18,6 +19,15 @@ export class EnumCompiler {
     this.snippets = new StandardSnippet(settings)
   }
 
+  private static getIndex (): string {
+    const lines = [
+      `export * from './all-enum'`,
+      `export * from './msg_tag'`,
+      ''
+    ]
+    return lines.join(require('os').EOL)
+  }
+
   /*
   enum MessageTypes {
   Logon = 'A',
@@ -34,6 +44,7 @@ export class EnumCompiler {
       })
       if (asOneFile) {
         await this.writeAsOne(asOneFile)
+        await this.writeFile('index', EnumCompiler.getIndex())
       }
     }).catch((e: Error) => {
       throw e

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

@@ -1,17 +1,17 @@
-import { ElasticBuffer, AsciiChars, Tags } from '../../buffer'
+import { ElasticBuffer, Tags } from '../../buffer'
+import { AsciiChars } from '../../buffer/ascii/'
 import { ICompilerSettings } from './compiler-settings'
 import { FixDefinitions } from '../definition'
-import { ContainedGroupField, ContainedSimpleField, ContainedComponentField } from '../contained'
+import { ContainedGroupField, ContainedSimpleField, ContainedComponentField, FieldsDispatch } from '../contained'
 import { StandardSnippet } from './standard-snippet'
-import { ContainedSetType } from '../dict-primitive'
 import { CompilerType } from './compiler-type'
 import { Dictionary } from '../../collections'
 
 import * as fs from 'fs'
 import * as Util from 'util'
 import * as Path from 'path'
-import { dispatchFields } from '../fields-dispatch'
-import { reduceSet } from '../set-reduce'
+import { SetReduce } from '../set-reduce'
+import { ContainedSetType } from '../contained-set-type'
 
 export class MsgCompiler {
   readonly queue: CompilerType[] = []
@@ -158,7 +158,7 @@ export class MsgCompiler {
 
   private fields (compilerType: CompilerType): void {
     this.attributes(compilerType)
-    dispatchFields(compilerType.set.fields, {
+    new FieldsDispatch().dispatchFields(compilerType.set.fields, {
       group: (g: ContainedGroupField) => this.fieldGroup(g, compilerType),
       simple: (simple: ContainedSimpleField) => this.fieldSimple(simple),
       component: (c: ContainedComponentField) => this.fieldComponent(c, compilerType)
@@ -180,9 +180,10 @@ export class MsgCompiler {
   }
 
   private imports (compilerType: CompilerType): number {
+    const reducer = new SetReduce<string[]>()
     const isMsg = compilerType.set.type === ContainedSetType.Msg
     const snippets = this.snippets
-    const imports: string[] = reduceSet<string[]>(compilerType.set, {
+    const imports: string[] = reducer.reduce(compilerType.set, {
       component: (a: string[], c: ContainedComponentField) => {
         a.push(`${snippets.import(compilerType.getExtended(c), isMsg, 0)}`)
         return a

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

@@ -1,5 +1,6 @@
 import { ComponentFieldDefinition } from '../definition'
-import { ContainedField, ContainedFieldType } from './contained-field'
+import { ContainedField } from './contained-field'
+import { ContainedFieldType } from './contained-field-type'
 
 export class ContainedComponentField extends ContainedField {
   constructor (public readonly definition: ComponentFieldDefinition,

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

@@ -1,13 +1,9 @@
 import { ContainedGroupField } from './contained-group-field'
 import { ContainedSimpleField } from './contained-simple-field'
 import { ContainedComponentField } from './contained-component-field'
-import { ContainedField, ContainedFieldType } from './contained-field'
-
-export interface IContainedFieldDispatcher {
-  group?: { (field: ContainedGroupField): void }
-  simple?: { (field: ContainedSimpleField): void }
-  component?: { (field: ContainedComponentField): void }
-}
+import { ContainedField } from './contained-field'
+import { IContainedFieldDispatcher } from './contained-field-dispatcher'
+import { ContainedFieldType } from './contained-field-type'
 
 export function dispatchContainedField (field: ContainedField, dispatcher: IContainedFieldDispatcher): void {
   switch (field.type) {

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

@@ -0,0 +1,9 @@
+import { ContainedGroupField } from './contained-group-field'
+import { ContainedSimpleField } from './contained-simple-field'
+import { ContainedComponentField } from './contained-component-field'
+
+export interface IContainedFieldDispatcher {
+  group?: { (field: ContainedGroupField): void }
+  simple?: { (field: ContainedSimpleField): void }
+  component?: { (field: ContainedComponentField): void }
+}

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

@@ -1,11 +1,13 @@
 import { INumericKeyed } from '../../collections/collection'
 import { Dictionary } from '../../collections'
 import { ContainedComponentField } from './contained-component-field'
-import { ContainedField, ContainedFieldType } from './contained-field'
+import { ContainedField } from './contained-field'
 import { ContainedGroupField } from './contained-group-field'
 import { ContainedSimpleField } from './contained-simple-field'
-import { ContainedSetType } from '../dict-primitive'
-import { ElasticBuffer, TagType } from '../../buffer'
+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'
 
 export abstract class ContainedFieldSet {
   public readonly groups: Dictionary<ContainedGroupField> = new Dictionary<ContainedGroupField>()

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

@@ -0,0 +1,5 @@
+export enum ContainedFieldType {
+  Component = 0,
+  Group = 1,
+  Simple = 2
+}