ts-edifact/lib/reader.js

Edifact parser library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Reader = void 0;
const parser_1 = require("./parser");
const validator_1 = require("./validator");
const segments_1 = require("./segments");
const elements_1 = require("./elements");
const util_1 = require("./util");
const cache_1 = require("./cache");
const configuration_1 = require("./configuration");
class DefinitionTables {
    constructor(segmentTable, elementTable) {
        this.segmentTable = segmentTable;
        this.elementTable = elementTable;
    }
}
class Reader {
    constructor(messageSpecDir) {
        this.defined = false;
        this.validationTables = [];
        this.definitionCache = new cache_1.Cache(15);
        this.unbCharsetDefined = false;
        const config = new configuration_1.Configuration({ validator: new validator_1.ValidatorImpl() });
        this.parser = new parser_1.Parser(config);
        this.validator = config.validator;
        this.result = [];
        const result = this.result;
        this.elements = [];
        let elements = this.elements;
        this.components = [];
        let components = this.components;
        let activeSegment;
        this.parser.onOpenSegment = (segment) => {
            elements = [];
            result.push({ name: segment, elements: elements });
            activeSegment = segment;
        };
        this.parser.onElement = () => {
            components = [];
            elements.push(components);
        };
        this.parser.onComponent = (value) => {
            if (activeSegment === "UNB" && !this.unbCharsetDefined) {
                this.parser.updateCharset(value);
                this.unbCharsetDefined = true;
            }
            components.push(value);
        };
        this.parser.onCloseSegment = () => {
            if ((0, util_1.isDefined)(activeSegment)) {
                if (activeSegment === "UNH") {
                    const messageType = elements[1][0];
                    const messageVersion = elements[1][1];
                    const messageRelease = elements[1][2];
                    const key = messageVersion + messageRelease + "_" + messageType;
                    if (this.definitionCache.contains(key)) {
                        const tables = this.definitionCache.get(key);
                        this.validator.define(tables.segmentTable);
                        this.validator.define(tables.elementTable);
                    }
                    else {
                        let segmentTableBuilder = new segments_1.SegmentTableBuilder(messageType);
                        let elementTableBuilder = new elements_1.ElementTableBuilder(messageType);
                        const version = (messageVersion + messageRelease).toUpperCase();
                        segmentTableBuilder = segmentTableBuilder.forVersion(version);
                        elementTableBuilder = elementTableBuilder.forVersion(version);
                        if (messageSpecDir) {
                            segmentTableBuilder = segmentTableBuilder.specLocation(messageSpecDir);
                            elementTableBuilder = elementTableBuilder.specLocation(messageSpecDir);
                        }
                        else {
                            segmentTableBuilder = segmentTableBuilder.specLocation("./");
                            elementTableBuilder = elementTableBuilder.specLocation("./");
                        }
                        const tables = new DefinitionTables(segmentTableBuilder.build(), elementTableBuilder.build());
                        this.validator.define(tables.segmentTable);
                        this.validator.define(tables.elementTable);
                        this.definitionCache.insert(key, tables);
                    }
                }
                activeSegment = null;
            }
        };
        this.separators = this.parser.separators();
    }
    define(definitions) {
        this.validator.define(definitions);
    }
    initializeIfNeeded() {
        if (!this.defined) {
            if (this.validationTables.length > 0) {
                for (const table of this.validationTables) {
                    this.validator.define(table);
                }
            }
            else {
                this.validator.define(segments_1.SegmentTableBuilder.enrichWithDefaultSegments(new validator_1.Dictionary()));
                this.validator.define(elements_1.ElementTableBuilder.enrichWithDefaultElements(new validator_1.Dictionary()));
            }
            this.defined = true;
        }
    }
    parse(document) {
        this.initializeIfNeeded();
        this.parser.write(document);
        this.parser.end();
        this.separators = this.parser.separators();
        return this.result;
    }
}
exports.Reader = Reader;
//# sourceMappingURL=reader.js.map