opcua-webapi-ts 1.0.19

package/dist/client/utils/UaDataTypeDictionary.d.ts

@@ -0,0 +1,15 @@
+import { UaDataType, UaNodeId } from "../../common";
+import { UaWebClient } from "../UaWebClient";
+export declare class UaDataTypeDictionary {
+    private static _abstractDataTypeIds;
+    private _dataTypes;
+    private _remainingNodesToBrowse;
+    private _remainingEnumerationToRead;
+    constructor();
+    read(client: UaWebClient): Promise<void>;
+    getDataType(nodeId: UaNodeId): UaDataType | null;
+    getDataTypes(): Array<UaDataType>;
+    private __browseDataTypes;
+    private __readEnumValues;
+    private __delay;
+}

package/dist/client/utils/UaDataTypeDictionary.js

@@ -0,0 +1,149 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaDataTypeDictionary = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const common_1 = require("../../common");
+class UaDataTypeDictionary {
+    constructor() {
+        if (null == UaDataTypeDictionary._abstractDataTypeIds) {
+            UaDataTypeDictionary._abstractDataTypeIds = new Set;
+            UaDataTypeDictionary._abstractDataTypeIds.add(common_1.DataTypeIds.BaseDataType);
+            UaDataTypeDictionary._abstractDataTypeIds.add(common_1.DataTypeIds.Number);
+            UaDataTypeDictionary._abstractDataTypeIds.add(common_1.DataTypeIds.Structure);
+            UaDataTypeDictionary._abstractDataTypeIds.add(common_1.DataTypeIds.Integer);
+            UaDataTypeDictionary._abstractDataTypeIds.add(common_1.DataTypeIds.UInteger);
+            UaDataTypeDictionary._abstractDataTypeIds.add(common_1.DataTypeIds.Enumeration);
+        }
+        this._dataTypes = new Map;
+        let baseDataTypeId = new common_1.UaNodeId(common_1.DataTypeIds.BaseDataType);
+        this._dataTypes.set(baseDataTypeId.toString(), new common_1.UaDataType(baseDataTypeId, "BaseDataType", new common_1.UaLocalizedText("BaseDataType"), true));
+        this._remainingNodesToBrowse = [new common_1.UaNodeId(common_1.DataTypeIds.BaseDataType)];
+        this._remainingEnumerationToRead = [];
+    }
+    read(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.__browseDataTypes(client);
+            yield this.__readEnumValues(client);
+        });
+    }
+    getDataType(nodeId) {
+        let dataType = this._dataTypes.get(nodeId.toString());
+        return (dataType) ? dataType : null;
+    }
+    getDataTypes() {
+        return [...this._dataTypes.values()];
+    }
+    __browseDataTypes(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (0 == this._remainingNodesToBrowse.length)
+                return;
+            let nodeIds = this._remainingNodesToBrowse.splice(0, 15);
+            let nodesToBrowse = [];
+            for (let item of nodeIds) {
+                nodesToBrowse.push({
+                    NodeId: item.toString(),
+                    BrowseDirection: opcua_webapi_1.BrowseDirection.Forward,
+                    ReferenceTypeId: new common_1.UaNodeId(common_1.ReferenceTypeIds.HasSubtype).toString(),
+                    IncludeSubtypes: false,
+                    NodeClassMask: opcua_webapi_1.NodeClass.DataType,
+                    ResultMask: 31
+                });
+            }
+            let results = yield client.browse(nodesToBrowse);
+            for (let i = 0; i < nodeIds.length; ++i) {
+                let statusCode = common_1.UaPayloadMapper.statusCodeFromWebApi(results[i].StatusCode);
+                if (statusCode.isNotGood() || !results[i].References)
+                    continue;
+                let parentType = this._dataTypes.get(nodeIds[i].toString());
+                for (let item of results[i].References) {
+                    let dataTypeId = (0, common_1.parseUaNodeIdOrNull)(item.NodeId);
+                    if (!dataTypeId || opcua_webapi_1.NodeClass.DataType != item.NodeClass ||
+                        !item.BrowseName || !item.DisplayName)
+                        continue;
+                    let isAbstract = false;
+                    if (dataTypeId.nsIndex == 0 &&
+                        UaDataTypeDictionary._abstractDataTypeIds.has(dataTypeId.numericId()))
+                        isAbstract = true;
+                    let dataType = new common_1.UaDataType(dataTypeId, item.BrowseName, common_1.UaPayloadMapper.localizedTextFromWebApi(item.DisplayName), isAbstract);
+                    this._dataTypes.set(dataTypeId.toString(), dataType);
+                    this._remainingNodesToBrowse.push(dataTypeId);
+                    if (parentType)
+                        dataType.setParentType(parentType);
+                    dataType.classify();
+                    if (common_1.DataTypeIds.Enumeration == dataType.valueType) {
+                        this._remainingEnumerationToRead.push(dataType.nodeId);
+                    }
+                }
+            }
+            if (this._remainingNodesToBrowse.length != 0) {
+                yield this.__delay(20);
+                yield this.__browseDataTypes(client);
+            }
+        });
+    }
+    __readEnumValues(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._remainingEnumerationToRead.length == 0)
+                return;
+            let nodeIds = this._remainingEnumerationToRead.splice(0, 20);
+            let nodesToBrowse = [];
+            for (let item of nodeIds) {
+                nodesToBrowse.push({
+                    NodeId: item.toString(),
+                    BrowseDirection: opcua_webapi_1.BrowseDirection.Forward,
+                    ReferenceTypeId: new common_1.UaNodeId(common_1.ReferenceTypeIds.HasProperty).toString(),
+                    IncludeSubtypes: false,
+                    NodeClassMask: opcua_webapi_1.NodeClass.Variable,
+                    ResultMask: 8
+                });
+            }
+            let results = yield client.browse(nodesToBrowse);
+            let enumDataTypeIds = [];
+            let enumValueIds = [];
+            for (let i = 0; i < nodeIds.length; ++i) {
+                let statusCode = common_1.UaPayloadMapper.statusCodeFromWebApi(results[i].StatusCode);
+                if (statusCode.isNotGood() || !results[i].References || results[i].References.length == 0)
+                    continue;
+                if (results[i].References[0].BrowseName == "EnumStrings" || results[i].References[0].BrowseName == "EnumValues") {
+                    let enumValueId = (0, common_1.parseUaNodeIdOrNull)(results[i].References[0].NodeId);
+                    if (enumValueId) {
+                        enumDataTypeIds.push(nodeIds[i]);
+                        enumValueIds.push(enumValueId);
+                    }
+                }
+            }
+            if (enumDataTypeIds.length != 0) {
+                let values = yield client.readValues(enumValueIds);
+                for (let i = 0; i < enumValueIds.length; ++i) {
+                    if (values[i].statusCode.isNotGood() ||
+                        values[i].value.arrayType != common_1.UaArrayType.Array)
+                        continue;
+                    let dataType = this._dataTypes.get(enumDataTypeIds[i].toString());
+                    if (!dataType)
+                        continue;
+                    dataType.setEnumValues(values[i].value);
+                }
+            }
+            if (this._remainingEnumerationToRead.length != 0) {
+                yield this.__delay(20);
+                yield this.__readEnumValues(client);
+            }
+        });
+    }
+    __delay(ms) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise(resolve => setTimeout(resolve, ms));
+        });
+    }
+}
+exports.UaDataTypeDictionary = UaDataTypeDictionary;
+UaDataTypeDictionary._abstractDataTypeIds = null;

package/dist/client/utils/UaNodeReader.d.ts

@@ -0,0 +1,83 @@
+import { UaLocalizedText, UaNode, UaNodeId, UaLink } from "../../common";
+import { UaWebClient } from "../UaWebClient";
+type NodeToBrowse = {
+    nodeId: UaNodeId;
+    nodeClassToReturn: number;
+};
+type CpToBrowse = {
+    nodeId: UaNodeId;
+    continuationPoint: string;
+};
+type BrowseResult = {
+    fromNodeId: UaNodeId;
+    nodeId: UaNodeId;
+    nodeClass: number;
+    browseName: string;
+    displayName: UaLocalizedText;
+    referenceTypeId: UaNodeId;
+    isForward: boolean;
+    typeDefinitionId?: UaNodeId;
+};
+type ReadResult = {
+    parentId: UaNodeId;
+    node: UaNode;
+};
+export type ReadChildResult = {
+    nodeId: UaNodeId;
+    children: Array<UaNode>;
+};
+export type ReadLinkResult = {
+    nodeId: UaNodeId;
+    links: Array<UaLink>;
+};
+export declare abstract class UaNodeReaderBase {
+    protected _finished: boolean;
+    protected _nodesToBrowse: Array<NodeToBrowse>;
+    protected _continuationPointToBrowse: Array<CpToBrowse>;
+    protected _browseResults: Array<BrowseResult>;
+    protected _readResults: Map<string, ReadResult>;
+    protected _nodeClassToReturn: number;
+    private static s_variableTypeWithoutMember;
+    private static s_variableNameToReadValue;
+    constructor(returnVariables?: boolean | null, returnMethod?: boolean | null);
+    protected _browseNodes(client: UaWebClient): Promise<void>;
+    protected _browseContinuationPoints(client: UaWebClient): Promise<void>;
+    protected _readNodes(client: UaWebClient): Promise<void>;
+    protected _buildNodeTree(): void;
+    private _readTypes;
+    private _readObjects;
+    private _readVariables;
+    private _readMethods;
+    private _updateNodesToBrowse;
+}
+export declare class UaNodeReader extends UaNodeReaderBase {
+    private _nodeIds;
+    private _isRootNodeRead;
+    constructor(nodeIds: Array<UaNodeId>, returnVariables?: boolean | null, returnMethod?: boolean | null);
+    readAll(client: UaWebClient): Promise<void>;
+    read(client: UaWebClient): Promise<void>;
+    isFinish(): boolean;
+    getResults(): Array<UaNode>;
+    private _readRootNodes;
+}
+export declare class UaNodeChildReader extends UaNodeReaderBase {
+    private _nodeIds;
+    constructor(nodeIds: Array<UaNodeId>, returnVariables?: boolean | null, returnMethod?: boolean | null);
+    readAll(client: UaWebClient): Promise<void>;
+    read(client: UaWebClient): Promise<void>;
+    isFinish(): boolean;
+    getResults(): Array<ReadChildResult>;
+}
+export declare class UaNodeLinkReader {
+    private _nodesToBrowse;
+    private _continuationPointToBrowse;
+    private _browseResults;
+    constructor(nodeIds: Array<UaNodeId>);
+    readAll(client: UaWebClient): Promise<void>;
+    read(client: UaWebClient): Promise<void>;
+    isFinish(): boolean;
+    getResults(): Array<ReadLinkResult>;
+    private _browseNodes;
+    private _browseContinuationPoints;
+}
+export {};