opcua-webapi-ts 1.0.19

package/dist/cjs/common/nodes/UaAttributes.d.ts

@@ -0,0 +1,18 @@
+import { UaLocalizedText, UaNodeId } from "../types";
+export type UaNodeAttributes = {
+    nodeClass: number;
+    browseName: string;
+    displayName: UaLocalizedText;
+    writeMask: number;
+    description: UaLocalizedText | null;
+};
+export type UaObjectAttributes = {
+    eventNotifier: number;
+};
+export type UaVariableAttributes = {
+    dataType: UaNodeId;
+    valueRank: number;
+    accessLevel: number;
+    userAccessLevel: number;
+    historizing: boolean;
+};

package/dist/cjs/common/nodes/UaAttributes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/common/nodes/UaDataType.d.ts

@@ -0,0 +1,15 @@
+import { NodeClass } from "opcua-webapi";
+import { UaLocalizedText, UaNodeId, UaVariant } from "../types";
+import { UaDefintionNode, UaVariable } from ".";
+export declare class UaDataType extends UaDefintionNode {
+    private _valueType;
+    private _enumValues;
+    constructor(nodeId: UaNodeId, browseName: string, displayName: UaLocalizedText, isAbstract: boolean, writeMask?: number | null);
+    get nodeClass(): NodeClass;
+    get valueType(): number;
+    get enumValues(): Map<number, UaLocalizedText> | null;
+    setEnumVariable(node: UaVariable): void;
+    setEnumValues(value: UaVariant): void;
+    classify(): void;
+    toJson(): any;
+}

package/dist/cjs/common/nodes/UaDataType.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaDataType = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const types_1 = require("../types");
+const _1 = require(".");
+const structure_1 = require("../structure");
+class UaDataType extends _1.UaDefintionNode {
+    constructor(nodeId, browseName, displayName, isAbstract, writeMask) {
+        super(nodeId, browseName, displayName, isAbstract, writeMask);
+        this._valueType = 0;
+        this._enumValues = null;
+    }
+    get nodeClass() {
+        return opcua_webapi_1.NodeClass.DataType;
+    }
+    get valueType() {
+        return this._valueType;
+    }
+    get enumValues() {
+        return this._enumValues;
+    }
+    setEnumVariable(node) {
+        if ("EnumStrings" == node.browseName ||
+            "EnumValues" == node.browseName) {
+            this.setEnumValues(node.value);
+        }
+    }
+    setEnumValues(value) {
+        if (types_1.UaVariantType.LocalizedText == value.type) {
+            let enumStrings = value.toLocalizedTexts();
+            if (null == enumStrings)
+                return;
+            this._enumValues = new Map;
+            let index = 0;
+            for (let item of enumStrings) {
+                this._enumValues.set(index, item);
+                index++;
+            }
+        }
+        else if (types_1.UaVariantType.ExtensionObject == value.type) {
+            let extensionObjects = value.toExtensionObjects();
+            if (null == extensionObjects)
+                return;
+            let enumValues = new Map;
+            for (let item of extensionObjects) {
+                let enumValue = structure_1.UaEnumValueType.fromExtensionObject(item);
+                if (!enumValue)
+                    return;
+                enumValues.set(enumValue.value, enumValue.displayName);
+            }
+            this._enumValues = enumValues;
+        }
+    }
+    classify() {
+        let isBasicDataType = false;
+        if (0 == this._nodeId.nsIndex) {
+            if (_1.DataTypeIds.Boolean <= this._nodeId.numericId() &&
+                _1.DataTypeIds.Structure >= this._nodeId.numericId())
+                isBasicDataType = true;
+            if (_1.DataTypeIds.Enumeration == this._nodeId.numericId())
+                isBasicDataType = true;
+        }
+        if (isBasicDataType) {
+            this._valueType = this._nodeId.numericId();
+        }
+        else {
+            this._valueType = (this.parentType()) ? this.parentType()._valueType : 0;
+        }
+    }
+    toJson() {
+        let enumValues = [];
+        if (this._enumValues) {
+            for (let item of this._enumValues) {
+                enumValues.push({
+                    value: item[0],
+                    text: item[1].text
+                });
+            }
+        }
+        let ret = {
+            nodeId: this._nodeId.toString(),
+            nodeClass: opcua_webapi_1.NodeClass.DataType,
+            name: this._browseName,
+            displayName: this._displayName.text,
+            description: (this._description) ? this._description.text : undefined,
+            isAbstract: this._isAbstract,
+            enumValues: (enumValues.length == 0) ? enumValues : undefined
+        };
+        return ret;
+    }
+}
+exports.UaDataType = UaDataType;

package/dist/cjs/common/nodes/UaMethod.d.ts

@@ -0,0 +1,16 @@
+import { NodeClass } from "opcua-webapi";
+import { UaLocalizedText, UaNodeId } from "../types";
+import { UaInstanceNode, UaVariable } from ".";
+import { UaArgument } from "../structure";
+export declare class UaMethod extends UaInstanceNode {
+    static InputArguments: string;
+    static OutputArguments: string;
+    private _inputArguments;
+    private _outputArguments;
+    constructor(nodeId: UaNodeId, browseName: string, displayName: UaLocalizedText);
+    get nodeClass(): NodeClass;
+    addMember(node: UaVariable): any;
+    get inputArguments(): Array<UaArgument> | null;
+    get outputArguments(): Array<UaArgument> | null;
+    toJson(): any;
+}

package/dist/cjs/common/nodes/UaMethod.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaMethod = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const _1 = require(".");
+const structure_1 = require("../structure");
+class UaMethod extends _1.UaInstanceNode {
+    constructor(nodeId, browseName, displayName) {
+        super(nodeId, browseName, displayName);
+        this._inputArguments = null;
+        this._outputArguments = null;
+    }
+    get nodeClass() {
+        return opcua_webapi_1.NodeClass.Method;
+    }
+    addMember(node) {
+        this._children.push(node);
+        let isInputArgument = null;
+        if (UaMethod.InputArguments == node.browseName) {
+            isInputArgument = true;
+        }
+        else if (UaMethod.OutputArguments == node.browseName) {
+            isInputArgument = false;
+        }
+        if (null == isInputArgument)
+            return;
+        let extensionObjects = node.value.toExtensionObjects();
+        if (null == extensionObjects)
+            return null;
+        let args = [];
+        for (let item2 of extensionObjects) {
+            let argument = structure_1.UaArgument.fromExtensionObject(item2);
+            if (null == argument)
+                return null;
+            args.push(argument);
+        }
+        if (isInputArgument) {
+            this._inputArguments = args;
+        }
+        else {
+            this._outputArguments = args;
+        }
+    }
+    get inputArguments() {
+        return this._inputArguments;
+    }
+    get outputArguments() {
+        return this._outputArguments;
+    }
+    toJson() {
+        let inputArgs = [];
+        let outputArgs = [];
+        if (this._inputArguments) {
+            for (let item of this._inputArguments) {
+                inputArgs.push(item.toJson());
+            }
+        }
+        if (this._outputArguments) {
+            for (let item of this._outputArguments) {
+                outputArgs.push(item.toJson());
+            }
+        }
+        let ret = {
+            nodeId: this._nodeId.toString(),
+            nodeClass: opcua_webapi_1.NodeClass.Method,
+            name: this._browseName,
+            displayName: this._displayName.text,
+            description: (this._description) ? this._description.text : undefined,
+            inputArguments: inputArgs,
+            outputArguments: outputArgs
+        };
+        return ret;
+    }
+}
+exports.UaMethod = UaMethod;
+UaMethod.InputArguments = "InputArguments";
+UaMethod.OutputArguments = "OutputArguments";

package/dist/cjs/common/nodes/UaNode.d.ts

@@ -0,0 +1,38 @@
+import { NodeClass } from "opcua-webapi";
+import { UaLocalizedText, UaNodeId } from "../types";
+export declare abstract class UaNode {
+    protected _nodeId: UaNodeId;
+    protected _browseName: string;
+    protected _displayName: UaLocalizedText;
+    protected _description: UaLocalizedText | undefined;
+    protected _writeMask: number;
+    protected _parent: UaNode | null;
+    protected _children: Array<UaNode>;
+    protected _refToParent: UaNodeId | undefined;
+    constructor(nodeId: UaNodeId, browseName: string, displayName: UaLocalizedText, writeMask?: number | null);
+    abstract get nodeClass(): NodeClass;
+    get nodeId(): UaNodeId;
+    get browseName(): string;
+    get displayName(): UaLocalizedText;
+    get writeMask(): number;
+    get description(): UaLocalizedText | null;
+    set description(description: UaLocalizedText);
+    get refToParent(): UaNodeId | null;
+    set refToParent(referenceTypeId: UaNodeId);
+    abstract toJson(): any;
+}
+export declare abstract class UaDefintionNode extends UaNode {
+    protected _isAbstract: boolean;
+    constructor(nodeId: UaNodeId, browseName: string, displayName: UaLocalizedText, isAbstract: boolean, writeMask?: number | null);
+    get isAbstract(): boolean;
+    get refToParent(): UaNodeId | null;
+    set refToParent(referenceTypeId: UaNodeId);
+    setParentType(parentType: UaDefintionNode): void;
+    isSubtypeOf(typeId: UaNodeId): boolean;
+    parentType(): UaDefintionNode | null;
+    childTypes(): Array<UaDefintionNode>;
+}
+export declare abstract class UaInstanceNode extends UaNode {
+    constructor(nodeId: UaNodeId, browseName: string, displayName: UaLocalizedText, writeMask?: number | null);
+    getMembers(nodeClass?: NodeClass): Array<UaInstanceNode>;
+}

package/dist/cjs/common/nodes/UaNode.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaInstanceNode = exports.UaDefintionNode = exports.UaNode = void 0;
+class UaNode {
+    constructor(nodeId, browseName, displayName, writeMask) {
+        this._nodeId = nodeId;
+        this._browseName = browseName;
+        this._displayName = displayName;
+        this._writeMask = (writeMask) ? writeMask : 0;
+        this._parent = null;
+        this._children = [];
+    }
+    get nodeId() {
+        return this._nodeId;
+    }
+    get browseName() {
+        return this._browseName;
+    }
+    get displayName() {
+        return this._displayName;
+    }
+    get writeMask() {
+        return this._writeMask;
+    }
+    get description() {
+        return (this._description) ? this._description : null;
+    }
+    set description(description) {
+        this._description = description;
+    }
+    get refToParent() {
+        return (this._refToParent) ? this._refToParent : null;
+    }
+    set refToParent(referenceTypeId) {
+        this._refToParent = referenceTypeId;
+    }
+}
+exports.UaNode = UaNode;
+class UaDefintionNode extends UaNode {
+    constructor(nodeId, browseName, displayName, isAbstract, writeMask) {
+        super(nodeId, browseName, displayName, writeMask);
+        this._isAbstract = isAbstract;
+    }
+    get isAbstract() {
+        return this._isAbstract;
+    }
+    get refToParent() {
+        return (this._refToParent) ? this._refToParent : null;
+    }
+    set refToParent(referenceTypeId) {
+        this._refToParent = referenceTypeId;
+    }
+    setParentType(parentType) {
+        if (parentType.nodeClass != this.nodeClass ||
+            null != this._parent)
+            return;
+        this._parent = parentType;
+        parentType._children.push(this);
+    }
+    isSubtypeOf(typeId) {
+        if (typeId.equal(this._nodeId))
+            return true;
+        if (null == this._parent)
+            return false;
+        return this._parent.isSubtypeOf(typeId);
+    }
+    parentType() {
+        return this._parent;
+    }
+    childTypes() {
+        let ret = [];
+        for (let item of this._children) {
+            if (item.nodeClass == this.nodeClass)
+                ret.push(item);
+        }
+        return ret;
+    }
+}
+exports.UaDefintionNode = UaDefintionNode;
+class UaInstanceNode extends UaNode {
+    constructor(nodeId, browseName, displayName, writeMask) {
+        super(nodeId, browseName, displayName, writeMask);
+    }
+    getMembers(nodeClass) {
+        let ret = [];
+        for (let item of this._children) {
+            if (nodeClass && nodeClass != item.nodeClass)
+                continue;
+            ret.push(item);
+        }
+        return ret;
+    }
+}
+exports.UaInstanceNode = UaInstanceNode;

package/dist/cjs/common/nodes/UaObject.d.ts

@@ -0,0 +1,16 @@
+import { NodeClass } from "opcua-webapi";
+import { UaLocalizedText, UaNodeId } from "../types";
+import { UaInstanceNode, UaMethod, UaVariable } from ".";
+export declare class UaObject extends UaInstanceNode {
+    private _typeDefinitionId;
+    private _eventNotifier;
+    constructor(nodeId: UaNodeId, browseName: string, displayName: UaLocalizedText, eventNotifier: number, typeDefinitionId: UaNodeId);
+    get nodeClass(): NodeClass;
+    get eventNotifier(): number;
+    get typeDefinitionId(): UaNodeId;
+    addMember(node: UaInstanceNode): void;
+    get objectMembers(): Array<UaObject>;
+    get variableMembers(): Array<UaVariable>;
+    get methodMembers(): Array<UaMethod>;
+    toJson(): any;
+}

package/dist/cjs/common/nodes/UaObject.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaObject = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const _1 = require(".");
+class UaObject extends _1.UaInstanceNode {
+    constructor(nodeId, browseName, displayName, eventNotifier, typeDefinitionId) {
+        super(nodeId, browseName, displayName);
+        this._eventNotifier = eventNotifier;
+        this._typeDefinitionId = typeDefinitionId;
+    }
+    get nodeClass() {
+        return opcua_webapi_1.NodeClass.Object;
+    }
+    get eventNotifier() {
+        return this._eventNotifier;
+    }
+    get typeDefinitionId() {
+        return this._typeDefinitionId;
+    }
+    addMember(node) {
+        this._children.push(node);
+    }
+    get objectMembers() {
+        let ret = [];
+        for (let item of this._children) {
+            if (opcua_webapi_1.NodeClass.Object != item.nodeClass)
+                continue;
+            ret.push(item);
+        }
+        return ret;
+    }
+    get variableMembers() {
+        let ret = [];
+        for (let item of this._children) {
+            if (opcua_webapi_1.NodeClass.Variable != item.nodeClass)
+                continue;
+            ret.push(item);
+        }
+        return ret;
+    }
+    get methodMembers() {
+        let ret = [];
+        for (let item of this._children) {
+            if (opcua_webapi_1.NodeClass.Method != item.nodeClass)
+                continue;
+            ret.push(item);
+        }
+        return ret;
+    }
+    toJson() {
+        let children = [];
+        for (let item of this._children) {
+            children.push(item.toJson());
+        }
+        let ret = {
+            nodeId: this._nodeId.toString(),
+            nodeClass: opcua_webapi_1.NodeClass.Object,
+            name: this._browseName,
+            displayName: this._displayName.text,
+            description: (this._description) ? this._description.text : undefined,
+            typeDefinition: this._typeDefinitionId.toString(),
+            eventNotifier: this._eventNotifier,
+            children: (children.length != 0) ? children : undefined
+        };
+        return ret;
+    }
+}
+exports.UaObject = UaObject;

package/dist/cjs/common/nodes/UaObjectType.d.ts

@@ -0,0 +1,12 @@
+import { NodeClass } from "opcua-webapi";
+import { UaLocalizedText, UaNodeId } from "../types";
+import { UaDefintionNode, UaObject, UaMethod, UaVariable, UaInstanceNode } from ".";
+export declare class UaObjectType extends UaDefintionNode {
+    constructor(nodeId: UaNodeId, browseName: string, displayName: UaLocalizedText, isAbstract: boolean);
+    get nodeClass(): NodeClass;
+    addMember(node: UaInstanceNode): void;
+    get objectMembers(): Array<UaObject>;
+    get variableMembers(): Array<UaVariable>;
+    get methodMembers(): Array<UaMethod>;
+    toJson(): any;
+}

package/dist/cjs/common/nodes/UaObjectType.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaObjectType = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const _1 = require(".");
+class UaObjectType extends _1.UaDefintionNode {
+    constructor(nodeId, browseName, displayName, isAbstract) {
+        super(nodeId, browseName, displayName, isAbstract);
+    }
+    get nodeClass() {
+        return opcua_webapi_1.NodeClass.ObjectType;
+    }
+    addMember(node) {
+        this._children.push(node);
+    }
+    get objectMembers() {
+        let ret = [];
+        for (let item of this._children) {
+            if (opcua_webapi_1.NodeClass.Object != item.nodeClass)
+                continue;
+            ret.push(item);
+        }
+        return ret;
+    }
+    get variableMembers() {
+        let ret = [];
+        for (let item of this._children) {
+            if (opcua_webapi_1.NodeClass.Variable != item.nodeClass)
+                continue;
+            ret.push(item);
+        }
+        return ret;
+    }
+    get methodMembers() {
+        let ret = [];
+        for (let item of this._children) {
+            if (opcua_webapi_1.NodeClass.Method != item.nodeClass)
+                continue;
+            ret.push(item);
+        }
+        return ret;
+    }
+    toJson() {
+        let children = [];
+        for (let item of this._children) {
+            if (item.nodeClass == opcua_webapi_1.NodeClass.ObjectType)
+                continue;
+            children.push(item.toJson());
+        }
+        let ret = {
+            nodeId: this._nodeId.toString(),
+            nodeClass: opcua_webapi_1.NodeClass.ObjectType,
+            name: this._browseName,
+            displayName: this._displayName.text,
+            description: (this._description) ? this._description.text : undefined,
+            isAbstract: this._isAbstract,
+            children: (children.length != 0) ? children : undefined
+        };
+        return ret;
+    }
+}
+exports.UaObjectType = UaObjectType;

package/dist/cjs/common/nodes/UaReferenceType.d.ts

@@ -0,0 +1,12 @@
+import { NodeClass } from "opcua-webapi";
+import { UaLocalizedText, UaNodeId } from "../types";
+import { UaDefintionNode } from ".";
+export declare class UaReferenceType extends UaDefintionNode {
+    private _inverseName;
+    private _symmetric;
+    constructor(nodeId: UaNodeId, browseName: string, displayName: UaLocalizedText, isAbstract: boolean, inverseName: UaLocalizedText, symmetric: boolean);
+    get nodeClass(): NodeClass;
+    get inverseName(): UaLocalizedText;
+    get symmetric(): boolean;
+    toJson(): any;
+}

package/dist/cjs/common/nodes/UaReferenceType.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaReferenceType = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const _1 = require(".");
+class UaReferenceType extends _1.UaDefintionNode {
+    constructor(nodeId, browseName, displayName, isAbstract, inverseName, symmetric) {
+        super(nodeId, browseName, displayName, isAbstract);
+        this._inverseName = inverseName;
+        this._symmetric = symmetric;
+    }
+    get nodeClass() {
+        return opcua_webapi_1.NodeClass.ReferenceType;
+    }
+    get inverseName() {
+        return this._inverseName;
+    }
+    get symmetric() {
+        return this._symmetric;
+    }
+    toJson() {
+        let ret = {
+            nodeId: this._nodeId.toString(),
+            nodeClass: opcua_webapi_1.NodeClass.ReferenceType,
+            name: this._browseName,
+            displayName: this._displayName.text,
+            description: (this._description) ? this._description.text : undefined,
+            isAbstract: this._isAbstract
+        };
+        return ret;
+    }
+}
+exports.UaReferenceType = UaReferenceType;

package/dist/cjs/common/nodes/UaVariable.d.ts

@@ -0,0 +1,25 @@
+import { NodeClass } from "opcua-webapi";
+import { UaLocalizedText, UaNodeId, UaVariant } from "../types";
+import { UaInstanceNode } from ".";
+export declare class UaVariable extends UaInstanceNode {
+    private _typeDefinitionId;
+    private _dataType;
+    private _valueRank;
+    private _accessLevel;
+    private _userAccessLevel;
+    private _historizing;
+    private _value;
+    constructor(nodeId: UaNodeId, browseName: string, displayName: UaLocalizedText, dataType: UaNodeId, valueRank: number, accessLevel: number, userAccessLevel: number, historizing: boolean, typeDefinitionId: UaNodeId);
+    get nodeClass(): NodeClass;
+    get dataType(): UaNodeId;
+    get valueRank(): number;
+    get accessLevel(): number;
+    get userAccessLevel(): number;
+    get historizing(): boolean;
+    get value(): UaVariant;
+    set value(val: UaVariant);
+    get typeDefinitionId(): UaNodeId;
+    addMember(node: UaVariable): void;
+    get variableMembers(): Array<UaVariable>;
+    toJson(): any;
+}

package/dist/cjs/common/nodes/UaVariable.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaVariable = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const types_1 = require("../types");
+const _1 = require(".");
+class UaVariable extends _1.UaInstanceNode {
+    constructor(nodeId, browseName, displayName, dataType, valueRank, accessLevel, userAccessLevel, historizing, typeDefinitionId) {
+        super(nodeId, browseName, displayName);
+        this._dataType = dataType;
+        this._valueRank = valueRank;
+        this._accessLevel = accessLevel;
+        this._userAccessLevel = userAccessLevel;
+        this._historizing = historizing;
+        this._value = types_1.UaVariant.null();
+        this._typeDefinitionId = typeDefinitionId;
+    }
+    get nodeClass() {
+        return opcua_webapi_1.NodeClass.Variable;
+    }
+    get dataType() {
+        return this._dataType;
+    }
+    get valueRank() {
+        return this._valueRank;
+    }
+    get accessLevel() {
+        return this._accessLevel;
+    }
+    get userAccessLevel() {
+        return this._userAccessLevel;
+    }
+    get historizing() {
+        return this._historizing;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(val) {
+        this._value = val;
+    }
+    get typeDefinitionId() {
+        return this._typeDefinitionId;
+    }
+    addMember(node) {
+        this._children.push(node);
+    }
+    get variableMembers() {
+        let ret = [];
+        for (let item of this._children) {
+            ret.push(item);
+        }
+        return ret;
+    }
+    toJson() {
+        let children = [];
+        for (let item of this._children) {
+            if (item.nodeClass != opcua_webapi_1.NodeClass.Variable)
+                continue;
+            children.push(item.toJson());
+        }
+        let ret = {
+            nodeId: this._nodeId.toString(),
+            nodeClass: opcua_webapi_1.NodeClass.Variable,
+            name: this._browseName,
+            displayName: this._displayName.text,
+            typeDefinition: this._typeDefinitionId.toString(),
+            dataType: this._dataType.toString(),
+            valueRank: this._valueRank,
+            accessLevel: this._accessLevel,
+            children: (children.length != 0) ? children : undefined
+        };
+        return ret;
+    }
+}
+exports.UaVariable = UaVariable;