@ngx-i18nsupport/ngx-i18nsupport-lib/esm2015/impl/abstract-message-parser.js

A Typescript library to work with Angular generated i18n files (xliff, xmb)

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
import { ParsedMessage } from './parsed-message';
import { EMPTY_TAG, END_TAG, ICU_MESSAGE, ICU_MESSAGE_REF, ParsedMesageTokenizer, PLACEHOLDER, START_TAG, TEXT } from './parsed-message-tokenizer';
import { DOMParser } from 'xmldom';
import { format, isNullOrUndefined } from 'util';
import { DOMUtilities } from './dom-utilities';
import { ParsedMessagePartICUMessage } from './parsed-message-part-icu-message';
/**
 * Created by roobm on 10.05.2017.
 * A message parser can parse the xml content of a translatable message.
 * It generates a ParsedMessage from it.
 * @abstract
 */
export class AbstractMessageParser {
    /**
     * Parse XML to ParsedMessage.
     * @param {?} xmlElement the xml representation
     * @param {?} sourceMessage optional original message that will be translated by normalized new one
     * Throws an error if normalized xml is not well formed.
     * @return {?}
     */
    createNormalizedMessageFromXML(xmlElement, sourceMessage) {
        /** @type {?} */
        const message = new ParsedMessage(this, sourceMessage);
        if (xmlElement) {
            message.setXmlRepresentation(xmlElement);
            this.addPartsOfNodeToMessage(xmlElement, message, false);
        }
        return message;
    }
    /**
     * Parse XML string to ParsedMessage.
     * @param {?} xmlString the xml representation without root element, e.g. this is <ph x></ph> an example.
     * @param {?} sourceMessage optional original message that will be translated by normalized new one
     * Throws an error if normalized xml is not well formed.
     * @return {?}
     */
    createNormalizedMessageFromXMLString(xmlString, sourceMessage) {
        /** @type {?} */
        const doc = new DOMParser().parseFromString('<dummy>' + xmlString + '</dummy>', 'text/xml');
        /** @type {?} */
        const xmlElement = (/** @type {?} */ (doc.childNodes.item(0)));
        return this.createNormalizedMessageFromXML(xmlElement, sourceMessage);
    }
    /**
     * recursively run through a node and add all identified parts to the message.
     * @private
     * @param {?} node node
     * @param {?} message message to be generated.
     * @param {?} includeSelf if true, add node by itself, otherwise only children.
     * @return {?}
     */
    addPartsOfNodeToMessage(node, message, includeSelf) {
        /** @type {?} */
        let processChildren = true;
        if (includeSelf) {
            if (node.nodeType === node.TEXT_NODE) {
                message.addText(node.textContent);
                return;
            }
            if (node.nodeType === node.ELEMENT_NODE) {
                processChildren = this.processStartElement((/** @type {?} */ (node)), message);
            }
        }
        if (processChildren) {
            /** @type {?} */
            const icuMessageText = this.getICUMessageText(node);
            /** @type {?} */
            let isICU = !isNullOrUndefined(icuMessageText);
            if (isICU) {
                try {
                    message.addICUMessage(icuMessageText);
                }
                catch (error) {
                    // if it is not parsable, handle it as non ICU
                    console.log('non ICU message: ', icuMessageText, error);
                    isICU = false;
                }
            }
            if (!isICU) {
                /** @type {?} */
                const children = node.childNodes;
                for (let i = 0; i < children.length; i++) {
                    this.addPartsOfNodeToMessage(children.item(i), message, true);
                }
            }
        }
        if (node.nodeType === node.ELEMENT_NODE) {
            this.processEndElement((/** @type {?} */ (node)), message);
        }
    }
    /**
     * Return the ICU message content of the node, if it is an ICU Message.
     * @protected
     * @param {?} node node
     * @return {?} message or null, if it is no ICU Message.
     */
    getICUMessageText(node) {
        /** @type {?} */
        const children = node.childNodes;
        if (children.length === 0) {
            return null;
        }
        /** @type {?} */
        const firstChild = children.item(0);
        if (firstChild.nodeType === firstChild.TEXT_NODE) {
            if (this.isICUMessageStart(firstChild.textContent)) {
                return DOMUtilities.getXMLContent((/** @type {?} */ (node)));
            }
            else {
                return null;
            }
        }
        else {
            return null;
        }
    }
    /**
     * Test, wether text is beginning of ICU Message.
     * @param {?} text text
     * @return {?}
     */
    isICUMessageStart(text) {
        return ParsedMessagePartICUMessage.looksLikeICUMessage(text);
        //        return text.startsWith('{VAR_PLURAL') || text.startsWith('{VAR_SELECT');
    }
    /**
     * Parse normalized string to ParsedMessage.
     * @param {?} normalizedString normalized string
     * @param {?} sourceMessage optional original message that will be translated by normalized new one
     * @return {?} a new parsed message.
     * Throws an error if normalized string is not well formed.
     */
    parseNormalizedString(normalizedString, sourceMessage) {
        /** @type {?} */
        const message = new ParsedMessage(this, sourceMessage);
        /** @type {?} */
        const openTags = [];
        /** @type {?} */
        let tokens;
        try {
            tokens = new ParsedMesageTokenizer().tokenize(normalizedString);
        }
        catch (error) {
            throw new Error(format('unexpected error while parsing message: "%s" (parsed "%")', error.message, normalizedString));
        }
        tokens.forEach((/**
         * @param {?} token
         * @return {?}
         */
        (token) => {
            /** @type {?} */
            let disp = null;
            switch (token.type) {
                case TEXT:
                    message.addText(token.value.text);
                    break;
                case START_TAG:
                    message.addStartTag(token.value.name, token.value.idcounter);
                    openTags.push(token.value.name);
                    break;
                case END_TAG:
                    message.addEndTag(token.value.name);
                    if (openTags.length === 0 || openTags[openTags.length - 1] !== token.value.name) {
                        // oops, not well formed
                        throw new Error(format('unexpected close tag "%s" (parsed "%s")', token.value.name, normalizedString));
                    }
                    openTags.pop();
                    break;
                case EMPTY_TAG:
                    message.addEmptyTag(token.value.name, token.value.idcounter);
                    break;
                case PLACEHOLDER:
                    disp = (sourceMessage) ? sourceMessage.getPlaceholderDisp(token.value.idcounter) : null;
                    message.addPlaceholder(token.value.idcounter, disp);
                    break;
                case ICU_MESSAGE_REF:
                    disp = (sourceMessage) ? sourceMessage.getICUMessageRefDisp(token.value.idcounter) : null;
                    message.addICUMessageRef(token.value.idcounter, disp);
                    break;
                case ICU_MESSAGE:
                    throw new Error(format('<ICUMessage/> not allowed here, use parseICUMessage instead (parsed "%")', normalizedString));
                default:
                    break;
            }
        }));
        if (openTags.length > 0) {
            // oops, not well closed tags
            throw new Error(format('missing close tag "%s" (parsed "%s")', openTags[openTags.length - 1], normalizedString));
        }
        message.setXmlRepresentation(this.createXmlRepresentation(message));
        return message;
    }
    /**
     * Parse a string, that is an ICU message, to ParsedMessage.
     * @param {?} icuMessageString the message, like '{x, plural, =0 {nothing} =1 {one} other {many}}'.
     * @param {?} sourceMessage optional original message that will be translated by normalized new one
     * @return {?} a new parsed message.
     * Throws an error if icuMessageString has not the correct syntax.
     */
    parseICUMessage(icuMessageString, sourceMessage) {
        /** @type {?} */
        const message = new ParsedMessage(this, sourceMessage);
        message.addICUMessage(icuMessageString);
        return message;
    }
    /**
     * Helper function: Parse ID from a name.
     * name optionally ends with _<number>. This is the idcount.
     * E.g. name="TAG_IMG" returns 0
     * name = "TAG_IMG_1" returns 1
     * @protected
     * @param {?} name name
     * @return {?} id count
     */
    parseIdCountFromName(name) {
        /** @type {?} */
        const regex = /.*_([0-9]*)/;
        /** @type {?} */
        const match = regex.exec(name);
        if (isNullOrUndefined(match) || match[1] === '') {
            return 0;
        }
        else {
            /** @type {?} */
            const num = match[1];
            return parseInt(num, 10);
        }
    }
    /**
     * Create the native xml for a message.
     * Parts are already set here.
     * @protected
     * @param {?} message message
     * @return {?}
     */
    createXmlRepresentation(message) {
        /** @type {?} */
        const root = new DOMParser().parseFromString('<dummy/>', 'text/xml');
        /** @type {?} */
        const rootElem = root.getElementsByTagName('dummy').item(0);
        this.addXmlRepresentationToRoot(message, rootElem);
        return rootElem;
    }
    /**
     * @protected
     * @param {?} part
     * @param {?} rootElem
     * @return {?}
     */
    createXmlRepresentationOfTextPart(part, rootElem) {
        return rootElem.ownerDocument.createTextNode(part.asDisplayString());
    }
}
if (false) {
    /**
     * Handle this node.
     * This is called before the children are done.
     * @abstract
     * @protected
     * @param {?} elementNode elementNode
     * @param {?} message message to be altered
     * @return {?} true, if children should be processed too, false otherwise (children ignored then)
     */
    AbstractMessageParser.prototype.processStartElement = function (elementNode, message) { };
    /**
     * Handle end of this node.
     * This is called after all children are processed.
     * @abstract
     * @protected
     * @param {?} elementNode elementNode
     * @param {?} message message to be altered
     * @return {?}
     */
    AbstractMessageParser.prototype.processEndElement = function (elementNode, message) { };
    /**
     * @abstract
     * @protected
     * @param {?} message
     * @param {?} rootElem
     * @return {?}
     */
    AbstractMessageParser.prototype.addXmlRepresentationToRoot = function (message, rootElem) { };
    /**
     * the xml used for start tag in the message.
     * @abstract
     * @protected
     * @param {?} part part
     * @param {?} rootElem rootElem
     * @param {?=} id id number in xliff2
     * @return {?}
     */
    AbstractMessageParser.prototype.createXmlRepresentationOfStartTagPart = function (part, rootElem, id) { };
    /**
     * the xml used for end tag in the message.
     * @abstract
     * @protected
     * @param {?} part part
     * @param {?} rootElem rootElem
     * @return {?}
     */
    AbstractMessageParser.prototype.createXmlRepresentationOfEndTagPart = function (part, rootElem) { };
    /**
     * the xml used for empty tag in the message.
     * @abstract
     * @protected
     * @param {?} part part
     * @param {?} rootElem rootElem
     * @param {?=} id id number in xliff2
     * @return {?}
     */
    AbstractMessageParser.prototype.createXmlRepresentationOfEmptyTagPart = function (part, rootElem, id) { };
    /**
     * the xml used for placeholder in the message.
     * @abstract
     * @protected
     * @param {?} part part
     * @param {?} rootElem rootElem
     * @param {?=} id id number in xliff2
     * @return {?}
     */
    AbstractMessageParser.prototype.createXmlRepresentationOfPlaceholderPart = function (part, rootElem, id) { };
    /**
     * the xml used for icu message refs in the message.
     * @abstract
     * @protected
     * @param {?} part part
     * @param {?} rootElem rootElem
     * @return {?}
     */
    AbstractMessageParser.prototype.createXmlRepresentationOfICUMessageRefPart = function (part, rootElem) { };
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-message-parser.js","sourceRoot":"ng://@ngx-i18nsupport/ngx-i18nsupport-lib/","sources":["impl/abstract-message-parser.ts"],"names":[],"mappings":"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","sourcesContent":["import {ParsedMessage} from './parsed-message';\r\nimport {\r\n    EMPTY_TAG,\r\n    END_TAG, ICU_MESSAGE, ICU_MESSAGE_REF, ParsedMesageTokenizer, PLACEHOLDER, START_TAG, TEXT,\r\n    Token\r\n} from './parsed-message-tokenizer';\r\nimport {ParsedMessagePartText} from './parsed-message-part-text';\r\nimport {DOMParser} from 'xmldom';\r\nimport {ParsedMessagePartStartTag} from './parsed-message-part-start-tag';\r\nimport {ParsedMessagePartPlaceholder} from './parsed-message-part-placeholder';\r\nimport {ParsedMessagePartEndTag} from './parsed-message-part-end-tag';\r\nimport {IMessageParser} from './i-message-parser';\r\nimport {format, isNullOrUndefined} from 'util';\r\nimport {DOMUtilities} from './dom-utilities';\r\nimport {ParsedMessagePartEmptyTag} from './parsed-message-part-empty-tag';\r\nimport {ParsedMessagePartICUMessageRef} from './parsed-message-part-icu-message-ref';\r\nimport {ParsedMessagePartICUMessage} from './parsed-message-part-icu-message';\r\n/**\r\n * Created by roobm on 10.05.2017.\r\n * A message parser can parse the xml content of a translatable message.\r\n * It generates a ParsedMessage from it.\r\n */\r\nexport abstract class AbstractMessageParser implements IMessageParser {\r\n\r\n    /**\r\n     * Parse XML to ParsedMessage.\r\n     * @param xmlElement the xml representation\r\n     * @param sourceMessage optional original message that will be translated by normalized new one\r\n     * Throws an error if normalized xml is not well formed.\r\n     */\r\n    public createNormalizedMessageFromXML(xmlElement: Element, sourceMessage: ParsedMessage): ParsedMessage {\r\n        const message: ParsedMessage = new ParsedMessage(this, sourceMessage);\r\n        if (xmlElement) {\r\n            message.setXmlRepresentation(xmlElement);\r\n            this.addPartsOfNodeToMessage(xmlElement, message, false);\r\n        }\r\n        return message;\r\n    }\r\n\r\n    /**\r\n     * Parse XML string to ParsedMessage.\r\n     * @param xmlString the xml representation without root element, e.g. this is <ph x></ph> an example.\r\n     * @param sourceMessage optional original message that will be translated by normalized new one\r\n     * Throws an error if normalized xml is not well formed.\r\n     */\r\n    createNormalizedMessageFromXMLString(xmlString: string, sourceMessage: ParsedMessage): ParsedMessage {\r\n        const doc: Document = new DOMParser().parseFromString('<dummy>' + xmlString + '</dummy>', 'text/xml');\r\n        const xmlElement: Element = <Element> doc.childNodes.item(0);\r\n        return this.createNormalizedMessageFromXML(xmlElement, sourceMessage);\r\n    }\r\n\r\n    /**\r\n     * recursively run through a node and add all identified parts to the message.\r\n     * @param node node\r\n     * @param message message to be generated.\r\n     * @param includeSelf if true, add node by itself, otherwise only children.\r\n     */\r\n    private addPartsOfNodeToMessage(node: Node, message: ParsedMessage, includeSelf: boolean) {\r\n        let processChildren = true;\r\n        if (includeSelf) {\r\n            if (node.nodeType === node.TEXT_NODE) {\r\n                message.addText(node.textContent);\r\n                return;\r\n            }\r\n            if (node.nodeType === node.ELEMENT_NODE) {\r\n                processChildren = this.processStartElement(<Element> node, message);\r\n            }\r\n        }\r\n        if (processChildren) {\r\n            const icuMessageText = this.getICUMessageText(node);\r\n            let isICU = !isNullOrUndefined(icuMessageText);\r\n            if (isICU) {\r\n                try {\r\n                    message.addICUMessage(icuMessageText);\r\n                } catch (error) {\r\n                    // if it is not parsable, handle it as non ICU\r\n                    console.log('non ICU message: ', icuMessageText, error);\r\n                    isICU = false;\r\n                }\r\n            }\r\n            if (!isICU) {\r\n                const children = node.childNodes;\r\n                for (let i = 0; i < children.length; i++) {\r\n                    this.addPartsOfNodeToMessage(children.item(i), message, true);\r\n                }\r\n            }\r\n        }\r\n        if (node.nodeType === node.ELEMENT_NODE) {\r\n            this.processEndElement(<Element> node, message);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Return the ICU message content of the node, if it is an ICU Message.\r\n     * @param node node\r\n     * @return message or null, if it is no ICU Message.\r\n     */\r\n    protected getICUMessageText(node: Node): string {\r\n        const children = node.childNodes;\r\n        if (children.length === 0) {\r\n            return null;\r\n        }\r\n        const firstChild = children.item(0);\r\n        if (firstChild.nodeType === firstChild.TEXT_NODE) {\r\n            if (this.isICUMessageStart(firstChild.textContent)) {\r\n                return DOMUtilities.getXMLContent(<Element> node);\r\n            } else {\r\n                return null;\r\n            }\r\n        } else {\r\n            return null;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Test, wether text is beginning of ICU Message.\r\n     * @param text text\r\n     */\r\n    public isICUMessageStart(text: string): boolean {\r\n        return ParsedMessagePartICUMessage.looksLikeICUMessage(text);\r\n//        return text.startsWith('{VAR_PLURAL') || text.startsWith('{VAR_SELECT');\r\n    }\r\n\r\n    /**\r\n     * Handle this node.\r\n     * This is called before the children are done.\r\n     * @param elementNode elementNode\r\n     * @param message message to be altered\r\n     * @return true, if children should be processed too, false otherwise (children ignored then)\r\n     */\r\n    protected abstract processStartElement(elementNode: Element, message: ParsedMessage): boolean;\r\n\r\n    /**\r\n     * Handle end of this node.\r\n     * This is called after all children are processed.\r\n     * @param elementNode elementNode\r\n     * @param message message to be altered\r\n     */\r\n    protected abstract processEndElement(elementNode: Element, message: ParsedMessage);\r\n\r\n    /**\r\n     * Parse normalized string to ParsedMessage.\r\n     * @param normalizedString normalized string\r\n     * @param sourceMessage optional original message that will be translated by normalized new one\r\n     * @return a new parsed message.\r\n     * Throws an error if normalized string is not well formed.\r\n     */\r\n    public parseNormalizedString(normalizedString: string, sourceMessage: ParsedMessage): ParsedMessage {\r\n        const message: ParsedMessage = new ParsedMessage(this, sourceMessage);\r\n        const openTags = [];\r\n        let tokens: Token[];\r\n        try {\r\n            tokens = new ParsedMesageTokenizer().tokenize(normalizedString);\r\n        } catch (error) {\r\n            throw new Error(format('unexpected error while parsing message: \"%s\" (parsed \"%\")', error.message, normalizedString));\r\n        }\r\n        tokens.forEach((token: Token) => {\r\n            let disp: string = null;\r\n            switch (token.type) {\r\n                case TEXT:\r\n                    message.addText(token.value.text);\r\n                    break;\r\n                case START_TAG:\r\n                    message.addStartTag(token.value.name, token.value.idcounter);\r\n                    openTags.push(token.value.name);\r\n                    break;\r\n                case END_TAG:\r\n                    message.addEndTag(token.value.name);\r\n                    if (openTags.length === 0 || openTags[openTags.length - 1] !== token.value.name) {\r\n                        // oops, not well formed\r\n                        throw new Error(format('unexpected close tag \"%s\" (parsed \"%s\")', token.value.name, normalizedString));\r\n                    }\r\n                    openTags.pop();\r\n                    break;\r\n                case EMPTY_TAG:\r\n                    message.addEmptyTag(token.value.name, token.value.idcounter);\r\n                    break;\r\n                case PLACEHOLDER:\r\n                    disp = (sourceMessage) ? sourceMessage.getPlaceholderDisp(token.value.idcounter) : null;\r\n                    message.addPlaceholder(token.value.idcounter, disp);\r\n                    break;\r\n                case ICU_MESSAGE_REF:\r\n                    disp = (sourceMessage) ? sourceMessage.getICUMessageRefDisp(token.value.idcounter) : null;\r\n                    message.addICUMessageRef(token.value.idcounter, disp);\r\n                    break;\r\n                case ICU_MESSAGE:\r\n                    throw new Error(format('<ICUMessage/> not allowed here, use parseICUMessage instead (parsed \"%\")', normalizedString));\r\n                default:\r\n                    break;\r\n            }\r\n        });\r\n        if (openTags.length > 0) {\r\n            // oops, not well closed tags\r\n            throw new Error(format('missing close tag \"%s\" (parsed \"%s\")', openTags[openTags.length - 1], normalizedString));\r\n        }\r\n        message.setXmlRepresentation(this.createXmlRepresentation(message));\r\n        return message;\r\n    }\r\n\r\n    /**\r\n     * Parse a string, that is an ICU message, to ParsedMessage.\r\n     * @param icuMessageString the message, like '{x, plural, =0 {nothing} =1 {one} other {many}}'.\r\n     * @param sourceMessage optional original message that will be translated by normalized new one\r\n     * @return a new parsed message.\r\n     * Throws an error if icuMessageString has not the correct syntax.\r\n     */\r\n    parseICUMessage(icuMessageString: string, sourceMessage: ParsedMessage): ParsedMessage {\r\n        const message: ParsedMessage = new ParsedMessage(this, sourceMessage);\r\n        message.addICUMessage(icuMessageString);\r\n        return message;\r\n    }\r\n\r\n    /**\r\n     * Helper function: Parse ID from a name.\r\n     * name optionally ends with _<number>. This is the idcount.\r\n     * E.g. name=\"TAG_IMG\" returns 0\r\n     * name = \"TAG_IMG_1\" returns 1\r\n     * @param name name\r\n     * @return id count\r\n     */\r\n    protected parseIdCountFromName(name: string): number {\r\n        const regex = /.*_([0-9]*)/;\r\n        const match = regex.exec(name);\r\n        if (isNullOrUndefined(match) || match[1] === '') {\r\n            return 0;\r\n        } else {\r\n            const num = match[1];\r\n            return parseInt(num, 10);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Create the native xml for a message.\r\n     * Parts are already set here.\r\n     * @param message message\r\n     */\r\n    protected createXmlRepresentation(message: ParsedMessage): Element {\r\n        const root: Document = new DOMParser().parseFromString('<dummy/>', 'text/xml');\r\n        const rootElem: Element = root.getElementsByTagName('dummy').item(0);\r\n        this.addXmlRepresentationToRoot(message, rootElem);\r\n        return rootElem;\r\n    }\r\n\r\n    protected abstract addXmlRepresentationToRoot(message: ParsedMessage, rootElem: Element);\r\n\r\n    protected createXmlRepresentationOfTextPart(part: ParsedMessagePartText, rootElem: Element): Node {\r\n        return rootElem.ownerDocument.createTextNode(part.asDisplayString());\r\n    }\r\n\r\n    /**\r\n     * the xml used for start tag in the message.\r\n     * @param part part\r\n     * @param rootElem rootElem\r\n     * @param id id number in xliff2\r\n     */\r\n    protected abstract createXmlRepresentationOfStartTagPart(part: ParsedMessagePartStartTag, rootElem: Element, id?: number): Node;\r\n\r\n    /**\r\n     * the xml used for end tag in the message.\r\n     * @param part part\r\n     * @param rootElem rootElem\r\n     */\r\n    protected abstract createXmlRepresentationOfEndTagPart(part: ParsedMessagePartEndTag, rootElem: Element): Node;\r\n\r\n    /**\r\n     * the xml used for empty tag in the message.\r\n     * @param part part\r\n     * @param rootElem rootElem\r\n     * @param id id number in xliff2\r\n     */\r\n    protected abstract createXmlRepresentationOfEmptyTagPart(part: ParsedMessagePartEmptyTag, rootElem: Element, id?: number): Node;\r\n\r\n    /**\r\n     * the xml used for placeholder in the message.\r\n     * @param part part\r\n     * @param rootElem rootElem\r\n     * @param id id number in xliff2\r\n     */\r\n    protected abstract createXmlRepresentationOfPlaceholderPart(part: ParsedMessagePartPlaceholder, rootElem: Element, id?: number): Node;\r\n\r\n    /**\r\n     * the xml used for icu message refs in the message.\r\n     * @param part part\r\n     * @param rootElem rootElem\r\n     */\r\n    protected abstract createXmlRepresentationOfICUMessageRefPart(part: ParsedMessagePartICUMessageRef, rootElem: Element): Node;\r\n}\r\n"]}