node-opcua-address-space 2.66.2 → 2.68.0

package/source/loader/make_xml_extension_object_parser.ts

@@ -1,10 +1,12 @@
-import { BasicTypeDefinition } from "node-opcua-factory";
-import { NodeId, NodeIdType } from "node-opcua-nodeid";
+import { make_warningLog } from "node-opcua-debug";
+import { coerceNodeId, NodeId, NodeIdType } from "node-opcua-nodeid";
 import { EnumDefinition, StructureDefinition } from "node-opcua-types";
 import { lowerFirstLetter } from "node-opcua-utils";
 import { DataType } from "node-opcua-variant";
 import { ReaderState, ReaderStateParserLike, ParserLike, XmlAttributes } from "node-opcua-xml2json";
 
+const warningLog = make_warningLog(__filename);
+
 const localizedTextReader: ReaderStateParserLike = {
     init(this: any) {
         this.localizedText = {};
@@ -28,6 +30,18 @@ const localizedTextReader: ReaderStateParserLike = {
     }
 };
 
+function clamp(value: number, minValue: number, maxValue: number) {
+    if(value < minValue) {
+        warningLog(`invalid value range : ${value} < ${minValue} but should be [${minValue} , ${maxValue}]`);
+        return minValue;
+    }
+    if(value > maxValue) {
+        warningLog(`invalid value range : ${value} > ${maxValue} but should be [${minValue} , ${maxValue}]`);
+        return maxValue;
+    }
+    return value;
+}
+
 const partials: { [key: string]: ReaderStateParserLike } = {
     LocalizedText: localizedTextReader,
     String: {
@@ -66,28 +80,28 @@ const partials: { [key: string]: ReaderStateParserLike } = {
     },
     Byte: {
         finish(this: any) {
-            this.value = parseInt(this.text, 10);
+            this.value = clamp(parseInt(this.text, 10), 0, 255);
         }
     },
     SByte: {
         finish(this: any) {
-            this.value = parseInt(this.text, 10);
+            this.value = clamp(parseInt(this.text, 10), -128, 127);
         }
     },
     Int8: {
         finish(this: any) {
-            this.value = parseInt(this.text, 10);
+            this.value = clamp(parseInt(this.text, 10), -128, 127);
         }
     },
 
     Int16: {
         finish(this: any) {
-            this.value = parseInt(this.text, 10);
+            this.value = clamp(parseInt(this.text, 10), -32768, 32767);
         }
     },
     Int32: {
         finish(this: any) {
-            this.value = parseInt(this.text, 10);
+            this.value = clamp(parseInt(this.text, 10), -2147483648, 2147483647);
         }
     },
     Int64: {
@@ -98,19 +112,19 @@ const partials: { [key: string]: ReaderStateParserLike } = {
 
     UInt8: {
         finish(this: any) {
-            this.value = parseInt(this.text, 10);
+            this.value = clamp(parseInt(this.text, 10), 0, 255);
         }
     },
 
     UInt16: {
         finish(this: any) {
-            this.value = parseInt(this.text, 10);
+            this.value = clamp(parseInt(this.text, 10), 0, 65535);
         }
     },
 
     UInt32: {
         finish(this: any) {
-            this.value = parseInt(this.text, 10);
+            this.value = clamp(parseInt(this.text, 10), 0, 4294967295);
         }
     },
 
@@ -132,6 +146,13 @@ const partials: { [key: string]: ReaderStateParserLike } = {
             /** to do */
             console.log(" Missing  Implemntation contact sterfive.com!");
         }
+    },
+
+    NodeId: {
+        finish(this: any) {
+            // to do check Local or GMT
+            this.value = coerceNodeId(this.text);
+        }
     }
 };
 
@@ -239,7 +260,7 @@ function _makeTypeReader(
                         if (fieldParser.finish) {
                             fieldParser.finish.call(this);
                         } else {
-                            console.log(" check " + fieldTypename);
+                            warningLog("xxx check " + fieldTypename);
                         }
                         this.parent.value = this.parent.value || {};
                         this.parent.value[elName] = _clone(this.value);

package/source_nodejs/generate_address_space.ts

@@ -18,7 +18,7 @@ export async function readNodeSet2XmlFile(xmlFile: string): Promise<string> {
         throw new Error(msg);
     }
     debugLog(" parsing ", xmlFile);
-    const xmlData = await fs.promises.readFile(xmlFile, "ascii");
+    const xmlData = await fs.promises.readFile(xmlFile, "utf-8");
     return xmlData;
 }
 export function generateAddressSpace(

package/src/base_node_impl.ts

@@ -1514,7 +1514,7 @@ function _propagate_ref(this: BaseNode, addressSpace: MinimalistAddressSpace, re
             }
         }
         // xx ignore this assert(reference.nodeId.toString() !== this.nodeId.toString());
-        // function w(s,l) { return (s+"                                                          ").substr(0,l);}
+        // function w(s,l) { return (s+"                                                          ").substring(0,l);}
         // if (reference.isForward) {
         //    console.log("  CHILD => ",w(related_node.browseName   + " " + related_node.nodeId.toString(),30),
         //    "  PARENT   ",w(this.browseName + " " + this.nodeId.toString(),30) , reference.toString());

package/src/extension_object_array_node.ts

@@ -23,7 +23,7 @@ const errorLog = make_errorLog(__filename);
  *
  */
 
-function getExtObjArrayNodeValue(this: any) {
+function getExtObjArrayNodeValue<T  extends ExtensionObject>(this: UADynamicVariableArray<T>) {
     return new Variant({
         arrayType: VariantArrayType.Array,
         dataType: DataType.ExtensionObject,
@@ -85,6 +85,7 @@ export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: U
     const namespace = parentFolder.namespace;
 
     const complexVariableType = addressSpace.findVariableType(options.complexVariableType);
+    // istanbul ignore next
     if (!complexVariableType) {
         throw new Error("cannot find complex variable type");
     }
@@ -100,6 +101,8 @@ export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: U
     assert(structure, "Structure Type not found: please check your nodeset file");
 
     const dataType = addressSpace.findDataType(variableType.dataType);
+
+    // istanbul ignore next
     if (!dataType) {
         errorLog(variableType.toString());
         throw new Error("cannot find Data Type");
@@ -123,7 +126,17 @@ export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: U
 
     return uaArrayVariableNode;
 }
+function _getElementBrowseName<T extends ExtensionObject>(this: UADynamicVariableArray<T>, extObj: ExtensionObject) {
+    const indexPropertyName1 = this.$$indexPropertyName;
 
+    if (!Object.prototype.hasOwnProperty.call(extObj, indexPropertyName1)) {
+        console.log(" extension object do not have ", indexPropertyName1, extObj);
+    }
+    // assert(extObj.constructor === addressSpace.constructExtensionObject(dataType));
+    assert(Object.prototype.hasOwnProperty.call(extObj, indexPropertyName1));
+    const browseName = (extObj as any)[indexPropertyName1].toString();
+    return browseName;
+};
 /**
  * @method bindExtObjArrayNode
  * @param uaArrayVariableNode
@@ -136,57 +149,54 @@ export function bindExtObjArrayNode<T extends ExtensionObject>(
     variableTypeNodeId: string | NodeId,
     indexPropertyName: string
 ): UAVariable {
+
+    assert(uaArrayVariableNode.valueRank === 1, "expecting a one dimension array");
+
     const addressSpace = uaArrayVariableNode.addressSpace;
 
     const variableType = addressSpace.findVariableType(variableTypeNodeId);
-    if (!variableType) {
+    
+    // istanbul ignore next
+    if (!variableType || variableType.nodeId.isEmpty()) {
         throw new Error("Cannot find VariableType " + variableTypeNodeId.toString());
     }
-    assert(!variableType.nodeId.isEmpty());
 
-    let structure = addressSpace.findDataType("Structure");
-    assert(structure, "Structure Type not found: please check your nodeset file");
+    const structure = addressSpace.findDataType("Structure");
+
+    // istanbul ignore next
+    if (!structure) {
+        throw new Error("Structure Type not found: please check your nodeset file");
+    }
 
     let dataType = addressSpace.findDataType(variableType.dataType);
+    
+    // istanbul ignore next
     if (!dataType) {
         throw new Error("Cannot find DataType " + variableType.dataType.toString());
     }
-    assert(dataType.isSupertypeOf(structure as any), "expecting a structure (= ExtensionObject) here ");
+    
+    assert(dataType.isSupertypeOf(structure), "expecting a structure (= ExtensionObject) here ");
 
     assert(!uaArrayVariableNode.$$variableType, "uaArrayVariableNode has already been bound !");
 
     uaArrayVariableNode.$$variableType = variableType;
 
-    structure = addressSpace.findDataType("Structure");
-    assert(structure, "Structure Type not found: please check your nodeset file");
-
     // verify that an object with same doesn't already exist
     dataType = addressSpace.findDataType(variableType.dataType)! as UADataType;
-    assert(dataType!.isSupertypeOf(structure as any), "expecting a structure (= ExtensionObject) here ");
+    assert(dataType!.isSupertypeOf(structure), "expecting a structure (= ExtensionObject) here ");
 
     uaArrayVariableNode.$$dataType = dataType;
     uaArrayVariableNode.$$extensionObjectArray = [];
     uaArrayVariableNode.$$indexPropertyName = indexPropertyName;
 
-    uaArrayVariableNode.$$getElementBrowseName = function (this: UADynamicVariableArray<T>, extObj: ExtensionObject) {
-        const indexPropertyName1 = this.$$indexPropertyName;
+    uaArrayVariableNode.$$getElementBrowseName = _getElementBrowseName;
 
-        if (!Object.prototype.hasOwnProperty.call(extObj, indexPropertyName1)) {
-            console.log(" extension object do not have ", indexPropertyName1, extObj);
-        }
-        // assert(extObj.constructor === addressSpace.constructExtensionObject(dataType));
-        assert(Object.prototype.hasOwnProperty.call(extObj, indexPropertyName1));
-        const browseName = (extObj as any)[indexPropertyName1].toString();
-        return browseName;
-    };
-
-    const options = {
+    const bindOptions: any = {
         get: getExtObjArrayNodeValue,
         set: undefined // readonly
     };
-
     // bind the readonly
-    uaArrayVariableNode.bindVariable(options, true);
+    uaArrayVariableNode.bindVariable(bindOptions, true);
 
     return uaArrayVariableNode;
 }
@@ -258,12 +268,12 @@ export function addElement<T extends ExtensionObject>(
             componentOf: uaArrayVariableNode.nodeId,
             value: { dataType: DataType.ExtensionObject, value: extensionObject }
         }) as UAVariableImpl;
-        elVar.bindExtensionObject();
+        elVar.bindExtensionObject(extensionObject,  { force: true });
         elVar.$extensionObject = extensionObject;
     }
 
     // also add the value inside
-    uaArrayVariableNode.$$extensionObjectArray.push(extensionObject);
+    uaArrayVariableNode.$$extensionObjectArray.push(elVar.$extensionObject);
 
     return elVar;
 }
@@ -288,11 +298,14 @@ export function removeElement<T extends ExtensionObject>(
     uaArrayVariableNode: UADynamicVariableArray<T>,
     element: any /* number | UAVariable | (a any) => boolean | ExtensionObject */
 ): void {
-    assert(element, "element must exist");
+    assert(element, "removeElement: element must exist");
     const _array = uaArrayVariableNode.$$extensionObjectArray;
+
+    // istanbul ignore next
     if (_array.length === 0) {
         throw new Error(" cannot remove an element from an empty array ");
     }
+    
     let elementIndex = -1;
 
     if (typeof element === "number") {
@@ -314,8 +327,10 @@ export function removeElement<T extends ExtensionObject>(
         assert(_array[0].constructor.name === (element as any).constructor.name, "element must match");
         elementIndex = _array.findIndex((x: any) => x === element);
     }
+    
+    // istanbul ignore next
     if (elementIndex < 0) {
-        throw new Error(" cannot find element matching " + element.toString());
+        throw new Error("removeElement: cannot find element matching " + element.toString());
     }
     return removeElementByIndex(uaArrayVariableNode, elementIndex);
 }

package/src/historical_access/address_space_historical_data_node.ts

@@ -172,7 +172,7 @@ export class VariableHistorian implements IVariableHistorian {
         reverseDataValue: boolean,
         callback: CallbackT<DataValue[]>
     ): void {
-        assert(callback instanceof Function);
+        assert(typeof callback === 'function');
 
         let dataValues = filter_dequeue(this._timeline, historyReadRawModifiedDetails, maxNumberToExtract, isReversed);
 
@@ -322,7 +322,7 @@ function _historyReadRawAsync(
     reverseDataValue: boolean,
     callback: CallbackT<DataValue[]>
 ) {
-    assert(callback instanceof Function);
+    assert(typeof callback === 'function');
     this.varHistorian!.extractDataValues(historyReadRawModifiedDetails, maxNumberToExtract, isReversed, reverseDataValue, callback);
 }
 
@@ -546,7 +546,7 @@ function _historyRead(
     continuationData: ContinuationData,
     callback: CallbackT<HistoryReadResult>
 ) {
-    assert(callback instanceof Function);
+    assert(typeof callback === 'function');
     if (historyReadDetails instanceof ReadRawModifiedDetails) {
         // note: only ReadRawModifiedDetails supported at this time
         return this._historyReadRawModify(context, historyReadDetails, indexRange, dataEncoding, continuationData, callback);

package/src/reference_impl.ts

@@ -50,7 +50,7 @@ function _arrow(text: string, length: number, isForward: boolean): string {
 }
 
 function _w(str: string, width: number): string {
-    return (str + "                                         ").substr(0, width);
+    return str.padEnd(width).substring(0, width);
 }
 
 function _localCoerceToNodeID(nodeIdLike: string | NodeIdLike | { nodeId: NodeId }): NodeId {