node-opcua-xml2json 2.51.0

package/pnpm-lock.yaml

@@ -0,0 +1,77 @@
+lockfileVersion: 5.3
+
+specifiers:
+  bomstrip: ^0.1.4
+  ltx: ^3.0.0
+  node-opcua-assert: 2.42.0
+  node-opcua-debug: 2.42.0
+  node-opcua-nodesets: 2.41.1
+  node-opcua-utils: 2.44.0
+  should: ^13.2.3
+  xml-writer: ^1.7.0
+
+dependencies:
+  bomstrip: 0.1.4
+  ltx: 3.0.0
+  node-opcua-assert: link:../node-opcua-assert
+  node-opcua-debug: link:../node-opcua-debug
+  node-opcua-utils: link:../node-opcua-utils
+  xml-writer: 1.7.0
+
+devDependencies:
+  node-opcua-nodesets: link:../node-opcua-nodesets
+  should: 13.2.3
+
+packages:
+
+  /bomstrip/0.1.4:
+    resolution: {integrity: sha1-aSNnOCHMVHEatlYtQIhSZVzBGys=}
+    dev: false
+
+  /ltx/3.0.0:
+    resolution: {integrity: sha512-bu3/4/ApUmMqVNuIkHaRhqVtEi6didYcBDIF56xhPRCzVpdztCipZ62CUuaxMlMBUzaVL93+4LZRqe02fuAG6A==}
+    engines: {node: '>= 12.4.0'}
+    dev: false
+
+  /should-equal/2.0.0:
+    resolution: {integrity: sha512-ZP36TMrK9euEuWQYBig9W55WPC7uo37qzAEmbjHz4gfyuXrEUgF8cUvQVO+w+d3OMfPvSRQJ22lSm8MQJ43LTA==}
+    dependencies:
+      should-type: 1.4.0
+    dev: true
+
+  /should-format/3.0.3:
+    resolution: {integrity: sha1-m/yPdPo5IFxT04w01xcwPidxJPE=}
+    dependencies:
+      should-type: 1.4.0
+      should-type-adaptors: 1.1.0
+    dev: true
+
+  /should-type-adaptors/1.1.0:
+    resolution: {integrity: sha512-JA4hdoLnN+kebEp2Vs8eBe9g7uy0zbRo+RMcU0EsNy+R+k049Ki+N5tT5Jagst2g7EAja+euFuoXFCa8vIklfA==}
+    dependencies:
+      should-type: 1.4.0
+      should-util: 1.0.1
+    dev: true
+
+  /should-type/1.4.0:
+    resolution: {integrity: sha1-B1bYzoRt/QmEOmlHcZ36DUz/XPM=}
+    dev: true
+
+  /should-util/1.0.1:
+    resolution: {integrity: sha512-oXF8tfxx5cDk8r2kYqlkUJzZpDBqVY/II2WhvU0n9Y3XYvAYRmeaf1PvvIvTgPnv4KJ+ES5M0PyDq5Jp+Ygy2g==}
+    dev: true
+
+  /should/13.2.3:
+    resolution: {integrity: sha512-ggLesLtu2xp+ZxI+ysJTmNjh2U0TsC+rQ/pfED9bUZZ4DKefP27D+7YJVVTvKsmjLpIi9jAa7itwDGkDDmt1GQ==}
+    dependencies:
+      should-equal: 2.0.0
+      should-format: 3.0.3
+      should-type: 1.4.0
+      should-type-adaptors: 1.1.0
+      should-util: 1.0.1
+    dev: true
+
+  /xml-writer/1.7.0:
+    resolution: {integrity: sha1-t28dWRwWomNOvbcDx729D9aBkGU=}
+    engines: {node: '>=0.4.0'}
+    dev: false

package/source/definition_parser.ts

@@ -0,0 +1,84 @@
+// <Definition Name="SomeName">
+//   <Field Name="Running" Value="0" dataType: [ValueRank="1"]>
+//      [<Description>text</Description>]
+//   <Field>
+// </Definition>
+import assert from "node-opcua-assert";
+import { ReaderStateParserLike, XmlAttributes } from "./xml2json";
+
+// <Definition Name="SomeName">
+//   <Field Name="Running" Value="0" dataType: [ValueRank="1"]>
+//      [<Description>text</Description>]
+//   <Field>
+// </Definition>
+//
+// Or
+//
+//  (IsOptionSet)
+//
+//
+export const _definitionParser: ReaderStateParserLike = {
+    init(this: any, name: string, attrs: XmlAttributes) {
+        assert(!this.parent.definitionFields || this.parent.definitionFields.length === 0);
+        this.parent.definitionFields = [];
+        this.parent.definitionName = attrs.SymbolicName || attrs.Name;
+        this.array = this.parent.definitionFields;
+        this.isUnion = attrs.IsUnion === "true" ? true : false;
+    },
+    parser: {
+        Field: {
+            init(this: any) {
+                this.description = undefined;
+            },
+            parser: {
+                Description: {
+                    finish(this: any) {
+                        this.parent.description = this.text;
+                    },
+                },
+            },
+            finish(this: any) {
+                const obj: any = {
+                    name: this.attrs.Name,
+                };
+                if (this.attrs.DataType !== undefined) {
+                    obj.dataType = this.attrs.DataType;
+                }
+                if (this.description) {
+                    obj.description = this.description;
+                }
+                if (this.attrs.Value !== undefined) {
+                    obj.value = parseInt(this.attrs.Value, 10);
+                }
+                if (this.attrs.ValueRank !== undefined) {
+                    obj.valueRank = parseInt(this.attrs.ValueRank, 10);
+                } else {
+                    // when not specified valueRank means Scalar and Scalar is -1
+                    obj.valueRank = -1;
+                }
+                if (this.attrs.ArrayDimensions !== undefined) {
+                    obj.arrayDimensions = this.attrs.ArrayDimensions.split(",").map((e: string) => parseInt(e, 10));
+                }
+
+                obj.isOptional = this.attrs.IsOptional === "true" ? true : false;
+
+                if (this.attrs.SymbolicName !== undefined) {
+                    obj.symbolicName = this.attrs.SymbolicName;
+                }
+                this.parent.array.push(obj);
+            },
+        },
+    },
+};
+export const definitionReaderStateParser: ReaderStateParserLike = {
+    parser: {
+        Definition: _definitionParser,
+    },
+    endElement(this: any) {
+        this._pojo = {
+            name: this.definitionName,
+
+            fields: this.definitionFields,
+        };
+    },
+};

package/source/extension_object_parser.ts

@@ -0,0 +1,276 @@
+import { ReaderState, ReaderStateParserLike, ParserLike, XmlAttributes } from "./xml2json";
+import { lowerFirstLetter } from "node-opcua-utils";
+
+function BasicType_parser(dataType: string, parseFunc: (this: any, text: string) => any): ParserLike {
+    const r: ReaderStateParserLike = {
+        init(this: any, elementName: string, attrs: XmlAttributes) {
+            this.value = undefined;
+        },
+        finish(this: any) {
+            this.value = parseFunc.call(this, this.text);
+        }
+    };
+    const _parser: ParserLike = {};
+    _parser[dataType] = r;
+    return _parser;
+}
+
+function ListOf(dataType: string, parseFunc: any) {
+    return {
+        init(this: any) {
+            this.value = [];
+        },
+
+        parser: BasicType_parser(dataType, parseFunc),
+
+        finish(this: any) {},
+        endElement(this: any, elementName: string) {
+            this.value.push(this.parser[elementName].value);
+        }
+    };
+}
+
+const localizedTextReader: ReaderStateParserLike = {
+    init(this: any) {
+        this.localizedText = {};
+    },
+    parser: {
+        Locale: {
+            finish(this: any) {
+                this.parent.localizedText = this.parent.localizedText || {};
+                this.parent.localizedText.locale = this.text.trim();
+            }
+        },
+        Text: {
+            finish(this: any) {
+                this.parent.localizedText = this.parent.localizedText || {};
+                this.parent.localizedText.text = this.text.trim();
+            }
+        }
+    },
+    finish(this: any) {
+        this.value = this.localizedText;
+    }
+};
+
+const partials: { [key: string]: ReaderStateParserLike } = {
+    LocalizedText: localizedTextReader,
+    String: {
+        finish(this: any) {
+            this.value = this.text;
+        }
+    },
+
+    Boolean: {
+        finish(this: any) {
+            this.value = this.text.toLowerCase() === "true";
+        }
+    },
+
+    ByteString: {
+        init(this: any) {
+            this.value = null;
+        },
+        finish(this: any) {
+            const base64text = this.text;
+            const byteString = Buffer.from(base64text, "base64");
+            this.value = byteString;
+        }
+    },
+
+    Float: {
+        finish(this: any) {
+            this.value = parseFloat(this.text);
+        }
+    },
+
+    Double: {
+        finish(this: any) {
+            this.value = parseFloat(this.text);
+        }
+    },
+
+    Int8: {
+        finish(this: any) {
+            this.value = parseInt(this.text, 10);
+        }
+    },
+
+    Int16: {
+        finish(this: any) {
+            this.value = parseInt(this.text, 10);
+        }
+    },
+    Int32: {
+        finish(this: any) {
+            this.value = parseInt(this.text, 10);
+        }
+    },
+    Int64: {
+        finish(this: any) {
+            this.value = parseInt(this.text, 10);
+        }
+    },
+
+    UInt8: {
+        finish(this: any) {
+            this.value = parseInt(this.text, 10);
+        }
+    },
+
+    UInt16: {
+        finish(this: any) {
+            this.value = parseInt(this.text, 10);
+        }
+    },
+    UInt32: {
+        finish(this: any) {
+            this.value = parseInt(this.text, 10);
+        }
+    },
+    UInt64: {
+        finish(this: any) {
+            this.value = parseInt(this.text, 10);
+        }
+    },
+
+    ListOfLocalizedText: {
+        init(this: any) {
+            this.value = [];
+        },
+        parser: { LocalizedText: localizedTextReader },
+        finish(this: any) {},
+        endElement(this: any /*element*/) {
+            this.value.push(this.parser.LocalizedText.value);
+        }
+    },
+
+    ListOfDouble: ListOf("Double", parseFloat),
+
+    ListOfFloat: ListOf("Float", parseFloat),
+
+    ListOfInt32: ListOf("Int32", parseInt),
+
+    ListOfInt16: ListOf("Int16", parseInt),
+
+    ListOfInt8: ListOf("Int8", parseInt),
+
+    ListOfUint32: ListOf("Uint32", parseInt),
+
+    ListOfUint16: ListOf("Uint16", parseInt),
+
+    ListOfUint8: ListOf("Uint8", parseInt)
+};
+
+interface Field {
+    dataType: any;
+    description?: string;
+    name: string;
+    value?: any;
+    valueRank?: number; // default is -1 => scalar
+}
+
+export interface Definition {
+    name: string;
+    fields: Field[];
+}
+
+export interface DefinitionMap {
+    findDefinition(name: string): Definition;
+}
+
+function _clone(a: any): any {
+    if (typeof a === "string" || typeof a === "number" || typeof a === "boolean") {
+        return a;
+    }
+    if (a instanceof Array) {
+        return a.map((x) => _clone(x));
+    }
+    return { ...a };
+}
+
+function _makeExtensionObjectReader(definitionName: string, definitionMap: DefinitionMap, readerMap: any): ReaderStateParserLike {
+    // is it a basic type ?
+    if (partials.hasOwnProperty(definitionName)) {
+        return partials[definitionName];
+    }
+
+    let reader: ReaderStateParserLike = readerMap[definitionName]!;
+
+    if (reader) {
+        return reader;
+    }
+    const definition = definitionMap.findDefinition(definitionName);
+    if (!definition) {
+        throw new Error("cannot find definition for " + definitionName);
+    }
+    reader = {
+        finish(this: any) {},
+        parser: {}
+    };
+
+    for (const field of definition.fields) {
+        const fieldReader = _makeExtensionObjectReader(field.dataType, definitionMap, readerMap);
+        if (!fieldReader) {
+            throw new Error(" Cannot find reader for dataType " + field.dataType);
+        }
+
+        if (field.valueRank === undefined || field.valueRank === -1) {
+            const parser = fieldReader;
+            if (!parser) {
+                throw new Error("??? " + field.dataType + "  " + field.name);
+            }
+            reader.parser![field.name] = {
+                parser: fieldReader.parser,
+                // endElement: fieldReader.endElement,
+                finish(this: any) {
+                    const elName = lowerFirstLetter(field.name);
+                    fieldReader.finish!.call(this);
+                    this.parent.value = this.parent.value || {};
+                    this.parent.value[elName] = _clone(this.value);
+                }
+            };
+        } else if (field.valueRank === 1) {
+            const listReader: ReaderStateParserLike = {
+                init(this: any) {
+                    this.value = [];
+                },
+                parser: {},
+                finish(this: any) {
+                    const elName = lowerFirstLetter(this.name);
+                    this.parent.value = this.parent.value || {};
+                    this.parent.value[elName] = this.value;
+                    this.value = undefined;
+                },
+                startElement(this: any, name: string, attrs: XmlAttributes) {
+                    // empty
+                },
+                endElement(this: any, element: string) {
+                    this.value.push(_clone(this.parser[element].value));
+                }
+            };
+            listReader.parser![field.dataType] = fieldReader;
+            reader.parser![field.name] = listReader;
+        } else {
+            throw new Error("Unsupported ValueRank !");
+        }
+    }
+    // xx const parser: ParserLike = {};
+    // xx parser[definition.name] = reader;
+    readerMap[definitionName] = reader;
+    return reader;
+}
+
+export function makeExtensionObjectReader(definitionName: string, definitionMap: DefinitionMap, readerMap: any) {
+    const reader1: ReaderStateParserLike = {
+        parser: {},
+        endElement(this: any) {
+            //         console.log(this.parser[definitionName].value);
+            this._pojo = this.parser[definitionName].value;
+        }
+    };
+
+    reader1.parser![definitionName] = _makeExtensionObjectReader(definitionName, definitionMap, readerMap);
+
+    return new ReaderState(reader1);
+}

package/source/fragment_cloner.ts

@@ -0,0 +1,51 @@
+import { Xml2Json, XmlAttributes, IReaderState } from "./xml2json";
+
+interface XmlWriter {
+    startElement(elementName: string): this;
+
+    endElement(): this;
+
+    writeAttribute(attributeName: string, attributeValue: string | number): this;
+
+    writeComment(comment: string): this;
+
+    text(str: string): this;
+}
+const XMLWriter = require("xml-writer");
+
+export class InternalFragmentClonerReaderState implements IReaderState {
+    private _xw: XmlWriter = new XMLWriter(true);
+    public value: any;
+    public initLevel: number = 0;
+    public engine?: Xml2Json;
+
+    public _on_startElement(level: number, elementName: string, attrs: XmlAttributes): void {
+        this._xw.startElement(elementName);
+        for (const [attName, attValue] of Object.entries(attrs)) {
+            this._xw.writeAttribute(attName, attValue);
+        }
+    }
+    public _on_endElement(level: number, elementName: string): void {
+        this._xw.endElement();
+        if (this.initLevel === level) {
+            this.value = this._xw.toString();
+            this.engine!._demote(this, this.engine!.currentLevel, elementName);
+            this.engine = undefined;
+            this._on_finish();
+        }
+    }
+    public _on_init(elementName: string, attrs: XmlAttributes, parent: IReaderState, level: number, engine: Xml2Json): void {
+        this.engine = engine;
+        this.initLevel = level;
+        this._xw = new XMLWriter(true);
+        this._xw.startElement(elementName);
+        for (const [attName, attValue] of Object.entries(attrs)) {
+            this._xw.writeAttribute(attName, attValue);
+        }
+    }
+    public _on_finish(): void {}
+    public _on_endElement2(level: number, elementName: string): void {}
+    public _on_text(text: string): void {
+        this._xw.text(text);
+    }
+}

package/source/fragment_cloner_parser.ts

@@ -0,0 +1,17 @@
+import { InternalFragmentClonerReaderState } from "./fragment_cloner";
+import { XmlAttributes } from "./xml2json";
+
+export class FragmentClonerParser {
+    public value: any;
+    private _cloneFragment?: InternalFragmentClonerReaderState;
+    constructor() {}
+
+    public startElement(this: any, elementName: string, attrs: XmlAttributes) {
+        this._cloneFragment = new InternalFragmentClonerReaderState();
+        this.engine!._promote(this._cloneFragment, this.engine!.currentLevel, elementName, attrs);
+    }
+    public finish() {
+        this.value = this._cloneFragment!.value;
+        this._cloneFragment!.value = null;
+    }
+}

package/source/index.ts

@@ -0,0 +1,6 @@
+export * from "./xml2json";
+export * from "./fragment_cloner";
+export * from "./xml2json_pojo";
+export * from "./fragment_cloner_parser";
+export * from "./extension_object_parser";
+export * from "./definition_parser";

package/source/nodejs/xml2json_fs.ts

@@ -0,0 +1,43 @@
+import * as fs from "fs";
+import { Callback, SimpleCallback, Xml2Json } from "../xml2json";
+
+export class Xml2JsonFs extends Xml2Json {
+    /**
+     * @method  parse
+     * @async
+     * @param xmlFile - the name of the xml file to parse.
+     */
+    public parse(xmlFile: string): Promise<any>;
+    public parse(xmlFile: string, callback: Callback<any> | SimpleCallback): void;
+    public parse(xmlFile: string, callback?: Callback<any> | SimpleCallback): any {
+        if (!callback) {
+            throw new Error("internal error");
+        }
+        const readWholeFile = true;
+        if (readWholeFile) {
+            // slightly faster but require more memory ..
+            fs.readFile(xmlFile, (err: Error | null, data: Buffer) => {
+                if (err) {
+                    return callback(err);
+                }
+                if (data[0] === 0xef && data[1] === 0xbb && data[2] === 0xbf) {
+                    data = data.slice(3);
+                }
+                const dataAsString = data.toString();
+                const parser = this._prepareParser(callback);
+                parser.write(dataAsString);
+                parser.end();
+            });
+        } else {
+            const Bomstrip = require("bomstrip");
+
+            const parser = this._prepareParser(callback);
+
+            fs.createReadStream(xmlFile, { autoClose: true, encoding: "utf8" }).pipe(new Bomstrip()).pipe(parser);
+        }
+    }
+}
+// tslint:disable:no-var-requires
+const thenify = require("thenify");
+const opts = { multiArgs: false };
+Xml2JsonFs.prototype.parse = thenify.withCallback(Xml2JsonFs.prototype.parse, opts);

package/source/xml2Json_pojo_tools.ts

@@ -0,0 +1,98 @@
+import { IReaderState, ReaderState, ReaderStateBase, ReaderStateParser, Xml2Json, XmlAttributes } from "./xml2json";
+import { lowerFirstLetter } from "node-opcua-utils";
+export type withPojoLambda = (name: string, pojo: any) => void;
+
+export class ReaderState2 extends ReaderStateBase {
+    public _stack: any;
+    public _pojo: any;
+    public _element: any;
+    public text: string;
+
+    public _withPojo: withPojoLambda;
+
+    private parent?: IReaderState;
+    private engine?: Xml2Json;
+    private initLevel: number = 0;
+
+    constructor() {
+        super();
+        this._pojo = {};
+        this._stack = [];
+        this._element = {};
+        this.text = "";
+        this.parent = undefined;
+        this._withPojo = (pojo: any) => {
+            /* empty */
+        };
+    }
+
+    public _on_init(elementName: string, attrs: XmlAttributes, parent: IReaderState, level: number, engine: Xml2Json): void {
+        this.parent = parent;
+        this.engine = engine;
+        this.initLevel = level;
+        if (this._stack.length === 0) {
+            this._pojo = {};
+            this._element = this._pojo;
+        }
+    }
+
+    public _on_finish() {
+        /* empy */
+    }
+
+    public _on_startElement(level: number, elementName: string, attrs: XmlAttributes): void {
+        this._stack.push(this._element);
+
+        if (elementName.match(/^ListOf/)) {
+            elementName = elementName.substring(6);
+            const elName = lowerFirstLetter(elementName);
+            if (this._element instanceof Array) {
+                const array: any[] = [];
+                this._element.push(array);
+                this._element = array;
+            } else {
+                this._element[elName] = [];
+                this._element = this._element[elName];
+            }
+        } else {
+            const elName = lowerFirstLetter(elementName);
+            if (this._element instanceof Array) {
+                const obj = {};
+                this._element.push(obj);
+                this._element = obj;
+            } else {
+                this._element[elName] = {};
+                this._element = this._element[elName];
+            }
+        }
+    }
+
+    public _on_endElement2(level: number, elementName: string): void {
+        /* empty */
+    }
+
+    public _on_endElement(level: number, elementName: string): void {
+        this._element = this._stack.pop();
+        if (this.text.length > 0 && this._element) {
+            const elName = lowerFirstLetter(elementName);
+            this._element[elName] = this.text;
+            // this.engine!._pojo = this._pojo;
+        } else {
+            const elName = lowerFirstLetter(elementName);
+            if (this.initLevel === level) {
+                if (this._withPojo) {
+                    if (this.text.length) {
+                        this._withPojo.call(null, elName, this.text);
+                    } else {
+                        this._withPojo.call(null, elName, this._pojo);
+                    }
+                }
+            }
+        }
+        this.text = "";
+    }
+
+    public _on_text(text: string): void {
+        this.text = text;
+    }
+}