jspurefix 5.3.0 → 5.5.0

package/dist/dictionary/parser/quickfix/index-visitor.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexVisitor = void 0;
+const contained_field_type_1 = require("../../contained/contained-field-type");
+const contained_set_builder_1 = require("../../contained/contained-set-builder");
+class IndexVisitor {
+    constructor() {
+        this.visited = new Set();
+    }
+    compute(definitions) {
+        const messages = new Set(definitions.message.values());
+        for (const msg of messages) {
+            this.reindex(msg);
+        }
+    }
+    reindex(set) {
+        if (this.visited.has(set))
+            return;
+        this.visited.add(set);
+        for (const field of set.fields) {
+            if (field.type === contained_field_type_1.ContainedFieldType.Group) {
+                const gf = field;
+                if (gf.definition)
+                    this.reindex(gf.definition);
+            }
+            else if (field.type === contained_field_type_1.ContainedFieldType.Component) {
+                const cf = field;
+                if (cf.definition)
+                    this.reindex(cf.definition);
+            }
+        }
+        const level0 = [...set.fields];
+        IndexVisitor.clearAggregated(set);
+        const builder = new contained_set_builder_1.ContainedSetBuilder(set);
+        for (const field of level0) {
+            builder.add(field);
+        }
+    }
+    static clearAggregated(set) {
+        set.fields.length = 0;
+        set.simple.clear();
+        set.groups.clear();
+        set.components.clear();
+        set.localNameToField.clear();
+        set.flattenedTag.length = 0;
+        set.localAttribute.length = 0;
+        set.nameToLocalAttribute.clear();
+        set.firstSimple = null;
+        set.containsRaw = false;
+        IndexVisitor.clearObject(set.containedTag);
+        IndexVisitor.clearObject(set.localTag);
+        IndexVisitor.clearObject(set.localRequired);
+        IndexVisitor.clearObject(set.tagToSimple);
+        IndexVisitor.clearObject(set.tagToField);
+        IndexVisitor.clearObject(set.containedLength);
+        const def = set;
+        if (def.noOfField) {
+            set.containedTag[def.noOfField.tag] = true;
+        }
+    }
+    static clearObject(obj) {
+        for (const k of Object.keys(obj)) {
+            delete obj[k];
+        }
+    }
+}
+exports.IndexVisitor = IndexVisitor;
+//# sourceMappingURL=index-visitor.js.map

package/dist/dictionary/parser/quickfix/index-visitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-visitor.js","sourceRoot":"","sources":["../../../../src/dictionary/parser/quickfix/index-visitor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Post-processing reindexer for ContainedFieldSet.\n *\n * After the graph parser drains its work queue, parent sets may not yet\n * know about all tags in their nested groups/components — because those\n * children may have been resolved AFTER the parent. This visitor walks\n * every message/component/group definition in post-order (children first),\n * clears the aggregated tag indices, and re-adds direct fields via\n * ContainedSetBuilder, which propagates child tags upward correctly.\n *\n * Equivalent to the C# IndexVisitor + ContainedFieldSet.Index() pair.\n */\nimport { ContainedFieldSet } from '../../contained/contained-field-set'\nimport { ContainedField } from '../../contained/contained-field'\nimport { ContainedFieldType } from '../../contained/contained-field-type'\nimport { ContainedGroupField } from '../../contained/contained-group-field'\nimport { ContainedComponentField } from '../../contained/contained-component-field'\nimport { ContainedSetBuilder } from '../../contained/contained-set-builder'\nimport { FixDefinitions } from '../../definition/fix-definitions'\nimport { IContainedSet } from '../../contained/contained-set'\n\nexport class IndexVisitor {\n  private readonly visited = new Set<IContainedSet>()\n\n  /**\n   * Reindex every message in the definitions. Components and groups are\n   * reindexed transitively as they are encountered during message reindexing.\n   */\n  compute (definitions: FixDefinitions): void {\n    // Use a Set to dedupe — definitions.message contains duplicate entries (by name + msgType + abbreviation)\n    const messages = new Set(definitions.message.values())\n    for (const msg of messages) {\n      this.reindex(msg)\n    }\n  }\n\n  /**\n   * Reindex a single set: post-order traversal ensures every nested\n   * group/component is fully indexed before its parent is rebuilt.\n   */\n  reindex (set: IContainedSet): void {\n    if (this.visited.has(set)) return\n    this.visited.add(set)\n\n    // First, recurse into all child groups/components (post-order)\n    for (const field of set.fields) {\n      if (field.type === ContainedFieldType.Group) {\n        const gf = field as ContainedGroupField\n        if (gf.definition) this.reindex(gf.definition)\n      } else if (field.type === ContainedFieldType.Component) {\n        const cf = field as ContainedComponentField\n        if (cf.definition) this.reindex(cf.definition)\n      }\n    }\n\n    // Save direct fields, clear all aggregated state, re-add via builder\n    const level0: ContainedField[] = [...set.fields]\n    IndexVisitor.clearAggregated(set as ContainedFieldSet)\n\n    const builder = new ContainedSetBuilder(set)\n    for (const field of level0) {\n      builder.add(field)\n    }\n  }\n\n  /**\n   * Reset every aggregated index on a set without touching its identity.\n   * Direct fields are passed back via the return of clearAggregated for\n   * the caller to re-add.\n   */\n  static clearAggregated (set: ContainedFieldSet): void {\n    set.fields.length = 0\n    set.simple.clear()\n    set.groups.clear()\n    set.components.clear()\n    set.localNameToField.clear()\n    set.flattenedTag.length = 0\n    set.localAttribute.length = 0\n    set.nameToLocalAttribute.clear()\n    set.firstSimple = null\n    set.containsRaw = false\n    IndexVisitor.clearObject(set.containedTag)\n    IndexVisitor.clearObject(set.localTag)\n    IndexVisitor.clearObject(set.localRequired)\n    IndexVisitor.clearObject(set.tagToSimple)\n    IndexVisitor.clearObject(set.tagToField)\n    IndexVisitor.clearObject(set.containedLength)\n    // Re-add the noOfField tag for groups (otherwise the group counter is lost)\n    const def = set as any\n    if (def.noOfField) {\n      set.containedTag[def.noOfField.tag] = true\n    }\n  }\n\n  private static clearObject (obj: Record<string, unknown>): void {\n    for (const k of Object.keys(obj)) {\n      delete obj[k]\n    }\n  }\n}\n"]}

package/dist/dictionary/parser/quickfix/index.d.ts

@@ -1 +1,8 @@
 export * from './quick-fix-xml-file-parser';
+export * from './quick-fix-graph-parser';
+export * from './quick-fix-graph-file-parser';
+export * from './x-element';
+export * from './sax-tree-builder';
+export * from './dictionary-validator';
+export * from './validation-error';
+export * from './index-visitor';

package/dist/dictionary/parser/quickfix/index.js

@@ -15,4 +15,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./quick-fix-xml-file-parser"), exports);
+__exportStar(require("./quick-fix-graph-parser"), exports);
+__exportStar(require("./quick-fix-graph-file-parser"), exports);
+__exportStar(require("./x-element"), exports);
+__exportStar(require("./sax-tree-builder"), exports);
+__exportStar(require("./dictionary-validator"), exports);
+__exportStar(require("./validation-error"), exports);
+__exportStar(require("./index-visitor"), exports);
 //# sourceMappingURL=index.js.map

package/dist/dictionary/parser/quickfix/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/dictionary/parser/quickfix/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8DAA2C","sourcesContent":["export * from './quick-fix-xml-file-parser'\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/dictionary/parser/quickfix/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8DAA2C;AAC3C,2DAAwC;AACxC,gEAA6C;AAC7C,8CAA2B;AAC3B,qDAAkC;AAClC,yDAAsC;AACtC,qDAAkC;AAClC,kDAA+B","sourcesContent":["export * from './quick-fix-xml-file-parser'\nexport * from './quick-fix-graph-parser'\nexport * from './quick-fix-graph-file-parser'\nexport * from './x-element'\nexport * from './sax-tree-builder'\nexport * from './dictionary-validator'\nexport * from './validation-error'\nexport * from './index-visitor'\n"]}

package/dist/dictionary/parser/quickfix/quick-fix-graph-file-parser.d.ts

@@ -0,0 +1,13 @@
+import { FixParser } from '../../fix-parser';
+import { FixDefinitions } from '../../definition/fix-definitions';
+import { GetJsFixLogger } from '../../../config';
+import { MakeDuplex } from '../../../transport';
+import { QuickFixGraphParserOptions } from './quick-fix-graph-parser';
+export declare class QuickFixGraphFileParser extends FixParser {
+    readonly make: MakeDuplex;
+    readonly getLogger: GetJsFixLogger;
+    readonly options: QuickFixGraphParserOptions;
+    constructor(make: MakeDuplex, getLogger: GetJsFixLogger, options?: QuickFixGraphParserOptions);
+    parse(): Promise<FixDefinitions>;
+    private readAll;
+}

package/dist/dictionary/parser/quickfix/quick-fix-graph-file-parser.js

@@ -0,0 +1,65 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickFixGraphFileParser = void 0;
+const fix_parser_1 = require("../../fix-parser");
+const fix_definitions_1 = require("../../definition/fix-definitions");
+const sax_tree_builder_1 = require("./sax-tree-builder");
+const quick_fix_graph_parser_1 = require("./quick-fix-graph-parser");
+const fix_definition_source_1 = require("../../fix-definition-source");
+const version_util_1 = require("../../version-util");
+class QuickFixGraphFileParser extends fix_parser_1.FixParser {
+    constructor(make, getLogger, options = {}) {
+        super();
+        this.make = make;
+        this.getLogger = getLogger;
+        this.options = options;
+    }
+    parse() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const xml = yield this.readAll();
+            const doc = sax_tree_builder_1.SaxTreeBuilder.parse(xml);
+            const fixRoot = doc.firstDescendant('fix');
+            if (!fixRoot)
+                throw new Error('no <fix> root element');
+            const major = parseInt((_a = fixRoot.attribute('major')) !== null && _a !== void 0 ? _a : '0', 10);
+            const minor = parseInt((_b = fixRoot.attribute('minor')) !== null && _b !== void 0 ? _b : '0', 10);
+            const servicepack = parseInt((_c = fixRoot.attribute('servicepack')) !== null && _c !== void 0 ? _c : '0', 10);
+            const description = (major !== 5 || servicepack === 0)
+                ? `FIX.${major}.${minor}`
+                : `FIX.${major}.${minor}SP${servicepack}`;
+            const definitions = new fix_definitions_1.FixDefinitions(fix_definition_source_1.FixDefinitionSource.QuickFix, version_util_1.VersionUtil.resolve(description));
+            const parser = new quick_fix_graph_parser_1.QuickFixGraphParser(definitions, this.options);
+            return parser.parseDocument(doc);
+        });
+    }
+    readAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const duplex = this.make();
+            const readable = duplex.readable;
+            return yield new Promise((resolve, reject) => {
+                const chunks = [];
+                readable.on('data', (chunk) => {
+                    chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+                });
+                readable.on('end', () => {
+                    resolve(Buffer.concat(chunks).toString('utf-8'));
+                });
+                readable.on('error', (err) => {
+                    reject(err);
+                });
+            });
+        });
+    }
+}
+exports.QuickFixGraphFileParser = QuickFixGraphFileParser;
+//# sourceMappingURL=quick-fix-graph-file-parser.js.map

package/dist/dictionary/parser/quickfix/quick-fix-graph-file-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quick-fix-graph-file-parser.js","sourceRoot":"","sources":["../../../../src/dictionary/parser/quickfix/quick-fix-graph-file-parser.ts"],"names":[],"mappings":";;;;;;;;;;;;AAKA,iDAA4C;AAC5C,sEAAiE;AAGjE,yDAAmD;AACnD,qEAA0F;AAC1F,uEAAiE;AACjE,qDAAgD;AAEhD,MAAa,uBAAwB,SAAQ,sBAAS;IACpD,YACkB,IAAgB,EAChB,SAAyB,EACzB,UAAsC,EAAE;QAExD,KAAK,EAAE,CAAA;QAJS,SAAI,GAAJ,IAAI,CAAY;QAChB,cAAS,GAAT,SAAS,CAAgB;QACzB,YAAO,GAAP,OAAO,CAAiC;IAG1D,CAAC;IAEY,KAAK;;;YAChB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE,CAAA;YAChC,MAAM,GAAG,GAAG,iCAAc,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;YAErC,MAAM,OAAO,GAAG,GAAG,CAAC,eAAe,CAAC,KAAK,CAAC,CAAA;YAC1C,IAAI,CAAC,OAAO;gBAAE,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAA;YACtD,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAA,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,mCAAI,GAAG,EAAE,EAAE,CAAC,CAAA;YAC7D,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAA,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,mCAAI,GAAG,EAAE,EAAE,CAAC,CAAA;YAC7D,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAA,OAAO,CAAC,SAAS,CAAC,aAAa,CAAC,mCAAI,GAAG,EAAE,EAAE,CAAC,CAAA;YACzE,MAAM,WAAW,GAAG,CAAC,KAAK,KAAK,CAAC,IAAI,WAAW,KAAK,CAAC,CAAC;gBACpD,CAAC,CAAC,OAAO,KAAK,IAAI,KAAK,EAAE;gBACzB,CAAC,CAAC,OAAO,KAAK,IAAI,KAAK,KAAK,WAAW,EAAE,CAAA;YAE3C,MAAM,WAAW,GAAG,IAAI,gCAAc,CAAC,2CAAmB,CAAC,QAAQ,EAAE,0BAAW,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAA;YACtG,MAAM,MAAM,GAAG,IAAI,4CAAmB,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;YACjE,OAAO,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,CAAA;QAClC,CAAC;KAAA;IAOa,OAAO;;YACnB,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,CAAA;YAC1B,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAA;YAChC,OAAO,MAAM,IAAI,OAAO,CAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACnD,MAAM,MAAM,GAAa,EAAE,CAAA;gBAC3B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAsB,EAAE,EAAE;oBAC7C,MAAM,CAAC,IAAI,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;gBACrE,CAAC,CAAC,CAAA;gBACF,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE;oBACtB,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAA;gBAClD,CAAC,CAAC,CAAA;gBACF,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAU,EAAE,EAAE;oBAClC,MAAM,CAAC,GAAG,CAAC,CAAA;gBACb,CAAC,CAAC,CAAA;YACJ,CAAC,CAAC,CAAA;QACJ,CAAC;KAAA;CACF;AAhDD,0DAgDC","sourcesContent":["/**\n * Drop-in replacement for QuickFixXmlFileParser that uses the graph-based\n * parser internally. Maintains the same constructor signature so it can be\n * swapped in the DefinitionFactory without changes to call sites.\n */\nimport { FixParser } from '../../fix-parser'\nimport { FixDefinitions } from '../../definition/fix-definitions'\nimport { GetJsFixLogger } from '../../../config'\nimport { MakeDuplex } from '../../../transport'\nimport { SaxTreeBuilder } from './sax-tree-builder'\nimport { QuickFixGraphParser, QuickFixGraphParserOptions } from './quick-fix-graph-parser'\nimport { FixDefinitionSource } from '../../fix-definition-source'\nimport { VersionUtil } from '../../version-util'\n\nexport class QuickFixGraphFileParser extends FixParser {\n  constructor (\n    public readonly make: MakeDuplex,\n    public readonly getLogger: GetJsFixLogger,\n    public readonly options: QuickFixGraphParserOptions = {}\n  ) {\n    super()\n  }\n\n  public async parse (): Promise<FixDefinitions> {\n    const xml = await this.readAll()\n    const doc = SaxTreeBuilder.parse(xml)\n\n    const fixRoot = doc.firstDescendant('fix')\n    if (!fixRoot) throw new Error('no <fix> root element')\n    const major = parseInt(fixRoot.attribute('major') ?? '0', 10)\n    const minor = parseInt(fixRoot.attribute('minor') ?? '0', 10)\n    const servicepack = parseInt(fixRoot.attribute('servicepack') ?? '0', 10)\n    const description = (major !== 5 || servicepack === 0)\n      ? `FIX.${major}.${minor}`\n      : `FIX.${major}.${minor}SP${servicepack}`\n\n    const definitions = new FixDefinitions(FixDefinitionSource.QuickFix, VersionUtil.resolve(description))\n    const parser = new QuickFixGraphParser(definitions, this.options)\n    return parser.parseDocument(doc)\n  }\n\n  /**\n   * Read the entire duplex stream into a UTF-8 string. The graph parser\n   * needs the full document in memory because it walks the XDocument tree\n   * with random access — unlike the legacy SAX-streaming parser.\n   */\n  private async readAll (): Promise<string> {\n    const duplex = this.make()\n    const readable = duplex.readable\n    return await new Promise<string>((resolve, reject) => {\n      const chunks: Buffer[] = []\n      readable.on('data', (chunk: Buffer | string) => {\n        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk)\n      })\n      readable.on('end', () => {\n        resolve(Buffer.concat(chunks).toString('utf-8'))\n      })\n      readable.on('error', (err: Error) => {\n        reject(err)\n      })\n    })\n  }\n}\n"]}

package/dist/dictionary/parser/quickfix/quick-fix-graph-parser.d.ts

@@ -0,0 +1,73 @@
+import { XDocument, XNode } from './x-element';
+import { DictionaryValidator } from './dictionary-validator';
+import { FixDefinitions } from '../../definition/fix-definitions';
+import { SimpleFieldDefinition } from '../../definition/simple-field-definition';
+import { MessageDefinition } from '../../definition/message-definition';
+export declare enum NodeElementType {
+    MessageDefinition = "MessageDefinition",
+    SimpleFieldDefinition = "SimpleFieldDefinition",
+    SimpleFieldDeclaration = "SimpleFieldDeclaration",
+    InlineGroupDefinition = "InlineGroupDefinition",
+    GroupDefinition = "GroupDefinition",
+    GroupDeclaration = "GroupDeclaration",
+    ComponentDefinition = "ComponentDefinition",
+    ComponentDeclaration = "ComponentDeclaration"
+}
+export interface Edge {
+    readonly head: number;
+    readonly tail: number;
+}
+export declare class GraphNode {
+    readonly id: number;
+    readonly name: string;
+    readonly type: NodeElementType;
+    readonly element: XNode;
+    private readonly _edges;
+    constructor(id: number, name: string, type: NodeElementType, element: XNode);
+    get edges(): ReadonlyArray<Edge>;
+    makeEdge(tail: number): Edge;
+    isRequired(): boolean;
+    toString(): string;
+}
+export interface QuickFixGraphParserOptions {
+    validateBeforeParsing?: boolean;
+}
+export declare class QuickFixGraphParser {
+    private readonly definitions;
+    private readonly nodes;
+    private readonly containedSets;
+    private readonly queue;
+    private nextId;
+    private header;
+    private trailer;
+    validator: DictionaryValidator | null;
+    readonly validateBeforeParsing: boolean;
+    constructor(definitions: FixDefinitions, options?: QuickFixGraphParserOptions);
+    parseText(xml: string): FixDefinitions;
+    parseDocument(doc: XDocument): FixDefinitions;
+    private makeNode;
+    private constructTailNode;
+    private parseVersion;
+    private parseFields;
+    private parseComponents;
+    private parseHeader;
+    private parseTrailer;
+    private parseMessages;
+    private work;
+    private getComponentDefinition;
+    private componentDeclaration;
+    private messageDefinition;
+    private componentDefinition;
+    private groupDefinition;
+    private inlineGroupDefinition;
+    private simpleFieldDeclaration;
+    private expandSet;
+    private expandField;
+    private expandGroup;
+    private expandComponent;
+    private expandSetChild;
+    static nameFrom(element: XNode): string;
+    static getField(element: XNode): SimpleFieldDefinition;
+    static getMessage(element: XNode): MessageDefinition;
+    static parse(xml: string, options?: QuickFixGraphParserOptions): FixDefinitions;
+}

package/dist/dictionary/parser/quickfix/quick-fix-graph-parser.js

@@ -0,0 +1,363 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickFixGraphParser = exports.GraphNode = exports.NodeElementType = void 0;
+const sax_tree_builder_1 = require("./sax-tree-builder");
+const dictionary_validator_1 = require("./dictionary-validator");
+const fix_definitions_1 = require("../../definition/fix-definitions");
+const simple_field_definition_1 = require("../../definition/simple-field-definition");
+const component_field_definition_1 = require("../../definition/component-field-definition");
+const group_field_definition_1 = require("../../definition/group-field-definition");
+const message_definition_1 = require("../../definition/message-definition");
+const contained_simple_field_1 = require("../../contained/contained-simple-field");
+const contained_component_field_1 = require("../../contained/contained-component-field");
+const contained_group_field_1 = require("../../contained/contained-group-field");
+const contained_set_builder_1 = require("../../contained/contained-set-builder");
+const fix_definition_source_1 = require("../../fix-definition-source");
+const version_util_1 = require("../../version-util");
+const index_visitor_1 = require("./index-visitor");
+var NodeElementType;
+(function (NodeElementType) {
+    NodeElementType["MessageDefinition"] = "MessageDefinition";
+    NodeElementType["SimpleFieldDefinition"] = "SimpleFieldDefinition";
+    NodeElementType["SimpleFieldDeclaration"] = "SimpleFieldDeclaration";
+    NodeElementType["InlineGroupDefinition"] = "InlineGroupDefinition";
+    NodeElementType["GroupDefinition"] = "GroupDefinition";
+    NodeElementType["GroupDeclaration"] = "GroupDeclaration";
+    NodeElementType["ComponentDefinition"] = "ComponentDefinition";
+    NodeElementType["ComponentDeclaration"] = "ComponentDeclaration";
+})(NodeElementType || (exports.NodeElementType = NodeElementType = {}));
+class GraphNode {
+    constructor(id, name, type, element) {
+        this.id = id;
+        this.name = name;
+        this.type = type;
+        this.element = element;
+        this._edges = [];
+    }
+    get edges() {
+        return this._edges;
+    }
+    makeEdge(tail) {
+        const edge = { head: this.id, tail };
+        this._edges.push(edge);
+        return edge;
+    }
+    isRequired() {
+        if (this.name === 'StandardHeader' || this.name === 'StandardTrailer')
+            return true;
+        return this.element.attribute('required') === 'Y';
+    }
+    toString() {
+        return `Node: id=${this.id}, name=${this.name}, type=${this.type}`;
+    }
+}
+exports.GraphNode = GraphNode;
+class QuickFixGraphParser {
+    constructor(definitions, options = {}) {
+        var _a;
+        this.nodes = new Map();
+        this.containedSets = new Map();
+        this.queue = [];
+        this.nextId = 0;
+        this.header = null;
+        this.trailer = null;
+        this.validator = null;
+        this.definitions = definitions;
+        this.validateBeforeParsing = (_a = options.validateBeforeParsing) !== null && _a !== void 0 ? _a : true;
+    }
+    parseText(xml) {
+        const doc = sax_tree_builder_1.SaxTreeBuilder.parse(xml);
+        return this.parseDocument(doc);
+    }
+    parseDocument(doc) {
+        if (this.validateBeforeParsing) {
+            this.validator = new dictionary_validator_1.DictionaryValidator();
+            this.validator.validate(doc);
+            this.validator.throwIfErrors();
+        }
+        this.parseVersion(doc);
+        this.parseFields(doc);
+        this.parseComponents(doc);
+        this.parseHeader(doc);
+        this.parseTrailer(doc);
+        this.parseMessages(doc);
+        while (this.queue.length > 0) {
+            const node = this.queue.shift();
+            this.work(node);
+        }
+        new index_visitor_1.IndexVisitor().compute(this.definitions);
+        return this.definitions;
+    }
+    makeNode(name, element, type) {
+        const node = new GraphNode(this.nextId++, name, type, element);
+        this.nodes.set(node.id, node);
+        this.queue.push(node);
+        return node;
+    }
+    constructTailNode(name, headNode, element, type) {
+        const tailNode = this.makeNode(name, element, type);
+        headNode.makeEdge(tailNode.id);
+        tailNode.makeEdge(headNode.id);
+    }
+    parseVersion(doc) {
+        var _a, _b, _c;
+        const version = doc.firstDescendant('fix');
+        if (!version)
+            throw new Error('no <fix> root element');
+        const major = parseInt((_a = version.attribute('major')) !== null && _a !== void 0 ? _a : '0', 10);
+        const minor = parseInt((_b = version.attribute('minor')) !== null && _b !== void 0 ? _b : '0', 10);
+        const servicepack = parseInt((_c = version.attribute('servicepack')) !== null && _c !== void 0 ? _c : '0', 10);
+        const description = (major !== 5 || servicepack === 0)
+            ? `FIX.${major}.${minor}`
+            : `FIX.${major}.${minor}SP${servicepack}`;
+        const resolved = version_util_1.VersionUtil.resolve(description);
+        if (resolved !== this.definitions.version) {
+            throw new Error(`version mismatch: dictionary declares ${description} but FixDefinitions was constructed with ${this.definitions.version}`);
+        }
+    }
+    parseFields(doc) {
+        const fieldsNode = doc.firstDescendant('fields');
+        if (!fieldsNode)
+            return;
+        for (const fieldElement of fieldsNode.elements('field')) {
+            this.makeNode(QuickFixGraphParser.nameFrom(fieldElement), fieldElement, NodeElementType.SimpleFieldDefinition);
+        }
+    }
+    parseComponents(doc) {
+        const componentsNode = doc.firstDescendant('components');
+        if (!componentsNode)
+            return;
+        for (const componentElement of componentsNode.elements('component')) {
+            this.makeNode(QuickFixGraphParser.nameFrom(componentElement), componentElement, NodeElementType.ComponentDefinition);
+        }
+    }
+    parseHeader(doc) {
+        const header = doc.firstDescendant('header');
+        if (!header)
+            throw new Error('no header declared in fix definitions');
+        this.header = this.makeNode('StandardHeader', header, NodeElementType.ComponentDefinition);
+    }
+    parseTrailer(doc) {
+        const trailer = doc.firstDescendant('trailer');
+        if (!trailer)
+            throw new Error('no trailer declared in fix definitions');
+        this.trailer = this.makeNode('StandardTrailer', trailer, NodeElementType.ComponentDefinition);
+    }
+    parseMessages(doc) {
+        const messagesNode = doc.firstDescendant('messages');
+        if (!messagesNode)
+            return;
+        for (const messageElement of messagesNode.elements('message')) {
+            const msgType = messageElement.attribute('msgtype');
+            if (!msgType)
+                continue;
+            this.makeNode(msgType, messageElement, NodeElementType.MessageDefinition);
+        }
+    }
+    work(node) {
+        switch (node.type) {
+            case NodeElementType.SimpleFieldDefinition: {
+                const sd = QuickFixGraphParser.getField(node.element);
+                this.definitions.addSimpleFieldDef(sd);
+                break;
+            }
+            case NodeElementType.MessageDefinition: {
+                this.messageDefinition(node);
+                break;
+            }
+            case NodeElementType.ComponentDefinition: {
+                this.componentDefinition(node);
+                break;
+            }
+            case NodeElementType.SimpleFieldDeclaration: {
+                this.simpleFieldDeclaration(node);
+                break;
+            }
+            case NodeElementType.InlineGroupDefinition: {
+                this.inlineGroupDefinition(node);
+                break;
+            }
+            case NodeElementType.GroupDefinition: {
+                this.groupDefinition(node);
+                break;
+            }
+            case NodeElementType.ComponentDeclaration: {
+                this.componentDeclaration(node);
+                break;
+            }
+            case NodeElementType.GroupDeclaration: {
+                break;
+            }
+        }
+    }
+    getComponentDefinition(node) {
+        let definition = this.definitions.component.get(node.name);
+        if (definition)
+            return definition;
+        definition = new component_field_definition_1.ComponentFieldDefinition(node.name, node.name, null, node.name);
+        this.definitions.addComponentFieldDef(definition);
+        return definition;
+    }
+    componentDeclaration(node) {
+        const definition = this.getComponentDefinition(node);
+        const edge = node.edges[0];
+        const parentSet = this.containedSets.get(edge.tail);
+        if (!parentSet) {
+            throw new Error(`edge tail ${edge.tail} has no contained set on which to place declared component '${node.name}'`);
+        }
+        const containedComponent = new contained_component_field_1.ContainedComponentField(definition, parentSet.fields.length, node.isRequired());
+        new contained_set_builder_1.ContainedSetBuilder(parentSet).add(containedComponent);
+        this.containedSets.set(edge.head, definition);
+    }
+    messageDefinition(node) {
+        if (!this.header)
+            throw new Error('header not set');
+        if (!this.trailer)
+            throw new Error('trailer not set');
+        const md = QuickFixGraphParser.getMessage(node.element);
+        this.definitions.addMessage(md);
+        this.containedSets.set(node.id, md);
+        this.constructTailNode('StandardHeader', node, this.header.element, NodeElementType.ComponentDeclaration);
+        this.expandSet(node);
+        this.constructTailNode('StandardTrailer', node, this.trailer.element, NodeElementType.ComponentDeclaration);
+    }
+    componentDefinition(node) {
+        const definition = this.getComponentDefinition(node);
+        this.containedSets.set(node.id, definition);
+        this.expandSet(node);
+    }
+    groupDefinition(node) {
+        var _a;
+        const tail = (_a = node.edges[0]) === null || _a === void 0 ? void 0 : _a.tail;
+        if (tail == null) {
+            throw new Error(`node ${node} has no edges to find tail for group definition`);
+        }
+        const definition = this.containedSets.get(tail);
+        if (!definition) {
+            throw new Error(`node ${node} has no contained set for group definition`);
+        }
+        this.containedSets.set(node.edges[0].head, definition);
+        this.expandSet(node);
+    }
+    inlineGroupDefinition(node) {
+        const edge = node.edges[0];
+        if (!edge) {
+            throw new Error(`node ${node} has no edges to find tail for inline group definition`);
+        }
+        const parentSet = this.containedSets.get(edge.tail);
+        if (!parentSet) {
+            throw new Error(`edge tail ${edge.tail} has no contained set for inline group '${node.name}'`);
+        }
+        const noOFieldDefinition = this.definitions.simple.get(node.name);
+        if (!noOFieldDefinition) {
+            throw new Error(`${node.name} does not exist in simple field definitions to construct inline group`);
+        }
+        const name = node.name;
+        const definition = new group_field_definition_1.GroupFieldDefinition(name, name, null, noOFieldDefinition, name);
+        const containedGroup = new contained_group_field_1.ContainedGroupField(definition, parentSet.fields.length, node.isRequired());
+        new contained_set_builder_1.ContainedSetBuilder(parentSet).add(containedGroup);
+        this.containedSets.set(edge.head, definition);
+        this.constructTailNode(name, node, node.element, NodeElementType.GroupDefinition);
+    }
+    simpleFieldDeclaration(node) {
+        const edge = node.edges[0];
+        if (!edge) {
+            throw new Error(`node ${node} has no edges to find tail for simple field declaration`);
+        }
+        const parentSet = this.containedSets.get(edge.tail);
+        if (!parentSet) {
+            throw new Error(`edge tail ${edge.tail} has no contained set for declared field '${node.name}'`);
+        }
+        const sd = this.definitions.simple.get(node.name);
+        if (!sd) {
+            throw new Error(`element ${node} cannot be located as a simple field`);
+        }
+        const containedSimpleField = new contained_simple_field_1.ContainedSimpleField(sd, parentSet.fields.length, node.isRequired(), false);
+        new contained_set_builder_1.ContainedSetBuilder(parentSet).add(containedSimpleField);
+    }
+    expandSet(node) {
+        for (const child of node.element.elements()) {
+            switch (child.name) {
+                case 'field': {
+                    this.expandField(node, child);
+                    break;
+                }
+                case 'group': {
+                    this.expandGroup(node, child);
+                    break;
+                }
+                case 'component': {
+                    this.expandComponent(node, child);
+                    break;
+                }
+            }
+        }
+    }
+    expandField(node, element) {
+        this.constructTailNode(QuickFixGraphParser.nameFrom(element), node, element, NodeElementType.SimpleFieldDeclaration);
+    }
+    expandGroup(node, element) {
+        this.expandSetChild(node, element, NodeElementType.InlineGroupDefinition, NodeElementType.GroupDeclaration);
+    }
+    expandComponent(node, element) {
+        this.expandSetChild(node, element, NodeElementType.ComponentDefinition, NodeElementType.ComponentDeclaration);
+    }
+    expandSetChild(node, element, defineElement, declareElement) {
+        const name = QuickFixGraphParser.nameFrom(element);
+        const hasInlinedFields = element.elements().length > 0;
+        const elementType = hasInlinedFields ? defineElement : declareElement;
+        this.constructTailNode(name, node, element, elementType);
+    }
+    static nameFrom(element) {
+        var _a;
+        let name = (_a = element.attribute('name')) !== null && _a !== void 0 ? _a : '';
+        name = name.replace(/ /g, '');
+        if (name.length > 0 && name[0] >= '0' && name[0] <= '9') {
+            name = `F${name}`;
+        }
+        return name;
+    }
+    static getField(element) {
+        var _a, _b;
+        const name = QuickFixGraphParser.nameFrom(element);
+        const numberStr = element.attribute('number');
+        const tag = numberStr != null ? parseInt(numberStr, 10) : -1;
+        if (tag < 0)
+            throw new Error(`no tag/number for ${name}`);
+        const type = (_a = element.attribute('type')) !== null && _a !== void 0 ? _a : 'STRING';
+        const sd = new simple_field_definition_1.SimpleFieldDefinition(String(tag), name, name, null, null, type, null);
+        for (const value of element.elements('value')) {
+            const enumKey = value.attribute('enum');
+            const description = (_b = value.attribute('description')) !== null && _b !== void 0 ? _b : '';
+            if (enumKey != null) {
+                sd.addEnum(enumKey, description, description);
+            }
+        }
+        return sd;
+    }
+    static getMessage(element) {
+        var _a, _b;
+        const name = QuickFixGraphParser.nameFrom(element);
+        const msgCat = (_a = element.attribute('msgcat')) !== null && _a !== void 0 ? _a : '';
+        const msgType = (_b = element.attribute('msgtype')) !== null && _b !== void 0 ? _b : '';
+        return new message_definition_1.MessageDefinition(name, name, msgType, msgCat, name);
+    }
+    static parse(xml, options = {}) {
+        var _a, _b, _c;
+        const doc = sax_tree_builder_1.SaxTreeBuilder.parse(xml);
+        const fixRoot = doc.firstDescendant('fix');
+        if (!fixRoot)
+            throw new Error('no <fix> root element');
+        const major = parseInt((_a = fixRoot.attribute('major')) !== null && _a !== void 0 ? _a : '0', 10);
+        const minor = parseInt((_b = fixRoot.attribute('minor')) !== null && _b !== void 0 ? _b : '0', 10);
+        const servicepack = parseInt((_c = fixRoot.attribute('servicepack')) !== null && _c !== void 0 ? _c : '0', 10);
+        const description = (major !== 5 || servicepack === 0)
+            ? `FIX.${major}.${minor}`
+            : `FIX.${major}.${minor}SP${servicepack}`;
+        const definitions = new fix_definitions_1.FixDefinitions(fix_definition_source_1.FixDefinitionSource.QuickFix, version_util_1.VersionUtil.resolve(description));
+        const parser = new QuickFixGraphParser(definitions, options);
+        return parser.parseDocument(doc);
+    }
+}
+exports.QuickFixGraphParser = QuickFixGraphParser;
+//# sourceMappingURL=quick-fix-graph-parser.js.map