opcua-webapi-ts 1.0.19

package/dist/cjs/common/types/UaHistoryDataResult.d.ts

@@ -0,0 +1,8 @@
+import { UaDataValue } from "./UaDataValue";
+export declare class UaHistoryDataResult {
+    private _historyData;
+    private _continuationPoint;
+    constructor(historyData: Array<UaDataValue>, continuationPoint?: string | null);
+    get historyData(): Array<UaDataValue>;
+    get continuationPoint(): string | null;
+}

package/dist/cjs/common/types/UaHistoryDataResult.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaHistoryDataResult = void 0;
+class UaHistoryDataResult {
+    constructor(historyData, continuationPoint) {
+        this._historyData = historyData;
+        this._continuationPoint = (continuationPoint) ? continuationPoint : null;
+    }
+    get historyData() {
+        return this._historyData;
+    }
+    get continuationPoint() {
+        return this._continuationPoint;
+    }
+}
+exports.UaHistoryDataResult = UaHistoryDataResult;

package/dist/cjs/common/types/UaHistoryEventFieldList.d.ts

@@ -0,0 +1,7 @@
+import { UaVariant } from "./UaVariant";
+export declare class UaHistoryEventFieldList {
+    private _eventFields;
+    constructor(eventFields: Array<UaVariant>);
+    get eventFields(): Array<UaVariant>;
+    getEventData(fieldNames: Array<string>): Map<string, UaVariant>;
+}

package/dist/cjs/common/types/UaHistoryEventFieldList.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaHistoryEventFieldList = void 0;
+class UaHistoryEventFieldList {
+    constructor(eventFields) {
+        this._eventFields = eventFields;
+    }
+    get eventFields() {
+        return this._eventFields;
+    }
+    getEventData(fieldNames) {
+        let eventData = new Map();
+        let index = 0;
+        for (let item of this._eventFields) {
+            if (this._eventFields.length <= index)
+                break;
+            eventData.set(fieldNames[index], item);
+            index++;
+        }
+        return eventData;
+    }
+}
+exports.UaHistoryEventFieldList = UaHistoryEventFieldList;

package/dist/cjs/common/types/UaHistoryEventResult.d.ts

@@ -0,0 +1,8 @@
+import { UaHistoryEventFieldList } from "./UaHistoryEventFieldList";
+export declare class UaHistoryEventResult {
+    private _historyEvents;
+    private _continuationPoint;
+    constructor(historyEvents: Array<UaHistoryEventFieldList>, continuationPoint?: string | null);
+    get historyEvents(): Array<UaHistoryEventFieldList>;
+    get continuationPoint(): string | null;
+}

package/dist/cjs/common/types/UaHistoryEventResult.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaHistoryEventResult = void 0;
+class UaHistoryEventResult {
+    constructor(historyEvents, continuationPoint) {
+        this._historyEvents = historyEvents;
+        this._continuationPoint = (continuationPoint) ? continuationPoint : null;
+    }
+    get historyEvents() {
+        return this._historyEvents;
+    }
+    get continuationPoint() {
+        return this._continuationPoint;
+    }
+}
+exports.UaHistoryEventResult = UaHistoryEventResult;

package/dist/cjs/common/types/UaLink.d.ts

@@ -0,0 +1,12 @@
+import { UaNodeId } from "./UaNodeId";
+export declare class UaLink {
+    private _targetId;
+    private _nodeClass;
+    private _referenceTypeId;
+    private _isForward;
+    constructor(targetId: UaNodeId, nodeClass: number, referenceTypeId: UaNodeId, isForward: boolean);
+    get targetId(): UaNodeId;
+    get nodeClass(): number;
+    get referenceTypeId(): UaNodeId;
+    get isForward(): boolean;
+}

package/dist/cjs/common/types/UaLink.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaLink = void 0;
+class UaLink {
+    constructor(targetId, nodeClass, referenceTypeId, isForward) {
+        this._targetId = targetId;
+        this._nodeClass = nodeClass;
+        this._referenceTypeId = referenceTypeId;
+        this._isForward = isForward;
+    }
+    get targetId() {
+        return this._targetId;
+    }
+    get nodeClass() {
+        return this._nodeClass;
+    }
+    get referenceTypeId() {
+        return this._referenceTypeId;
+    }
+    get isForward() {
+        return this._isForward;
+    }
+}
+exports.UaLink = UaLink;

package/dist/cjs/common/types/UaLocalizedText.d.ts

@@ -0,0 +1,9 @@
+export declare class UaLocalizedText {
+    static nullText: UaLocalizedText;
+    private _text;
+    private _locale;
+    constructor(text?: string | null, locale?: string | null);
+    get text(): string;
+    get locale(): string | null;
+    toString(): string;
+}

package/dist/cjs/common/types/UaLocalizedText.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaLocalizedText = void 0;
+class UaLocalizedText {
+    constructor(text, locale) {
+        this._text = (text) ? text : "";
+        this._locale = (locale) ? locale : null;
+    }
+    get text() {
+        return this._text;
+    }
+    get locale() {
+        return this._locale;
+    }
+    toString() {
+        return `Text: ${this._text} Locale: ${this._locale}`;
+    }
+}
+exports.UaLocalizedText = UaLocalizedText;
+UaLocalizedText.nullText = new UaLocalizedText();

package/dist/cjs/common/types/UaNodeId.d.ts

@@ -0,0 +1,23 @@
+export declare enum UaNodeIdType {
+    NUMERIC = 1,
+    STRING = 2,
+    GUID = 3,
+    BYTESTRING = 4
+}
+export declare class UaNodeId {
+    static nullNodeId: UaNodeId;
+    private _identifierType;
+    private _value;
+    private _nsIndex;
+    constructor(value: number | string, namespace?: number, identifierType?: UaNodeIdType);
+    get nsIndex(): number;
+    get value(): string | number;
+    get identifierType(): UaNodeIdType;
+    numericId(): number;
+    stringId(): string;
+    isEmpty(): boolean;
+    equal(other: UaNodeId | null): boolean;
+    toString(): string;
+}
+export declare function parseUaNodeId(value: string): UaNodeId;
+export declare function parseUaNodeIdOrNull(value: string | null | undefined): UaNodeId | null;

package/dist/cjs/common/types/UaNodeId.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaNodeId = exports.UaNodeIdType = void 0;
+exports.parseUaNodeId = parseUaNodeId;
+exports.parseUaNodeIdOrNull = parseUaNodeIdOrNull;
+const _1 = require(".");
+const opcua_webapi_1 = require("opcua-webapi");
+var UaNodeIdType;
+(function (UaNodeIdType) {
+    UaNodeIdType[UaNodeIdType["NUMERIC"] = 1] = "NUMERIC";
+    UaNodeIdType[UaNodeIdType["STRING"] = 2] = "STRING";
+    UaNodeIdType[UaNodeIdType["GUID"] = 3] = "GUID";
+    UaNodeIdType[UaNodeIdType["BYTESTRING"] = 4] = "BYTESTRING";
+})(UaNodeIdType || (exports.UaNodeIdType = UaNodeIdType = {}));
+class UaNodeId {
+    constructor(value, namespace, identifierType) {
+        this._value = (value) ? value : 0;
+        this._nsIndex = (namespace) ? namespace : 0;
+        if (typeof value === 'number') {
+            this._identifierType = UaNodeIdType.NUMERIC;
+        }
+        else {
+            this._identifierType = (identifierType) ? identifierType : UaNodeIdType.STRING;
+        }
+        if (this._nsIndex < 0 && this._nsIndex > 0xffff)
+            throw new _1.UaError((0, _1.makeUaStatusCode)(opcua_webapi_1.StatusCodes.BadNodeIdInvalid));
+        if (this._identifierType === UaNodeIdType.NUMERIC) {
+            if (typeof this._value !== "number" || this._value < 0 || this._value > 0xffffffff)
+                throw new _1.UaError((0, _1.makeUaStatusCode)(opcua_webapi_1.StatusCodes.BadNodeIdInvalid));
+        }
+        else if (this._identifierType === UaNodeIdType.STRING ||
+            this._identifierType === UaNodeIdType.BYTESTRING ||
+            this._identifierType === UaNodeIdType.GUID) {
+            if (typeof this._value !== "string")
+                throw new _1.UaError((0, _1.makeUaStatusCode)(opcua_webapi_1.StatusCodes.BadNodeIdInvalid));
+        }
+        else {
+            throw new _1.UaError((0, _1.makeUaStatusCode)(opcua_webapi_1.StatusCodes.BadNodeIdInvalid));
+        }
+    }
+    get nsIndex() {
+        return this._nsIndex;
+    }
+    get value() {
+        return this._value;
+    }
+    get identifierType() {
+        return this._identifierType;
+    }
+    numericId() {
+        return (this._identifierType === UaNodeIdType.NUMERIC) ? this._value : 0;
+    }
+    stringId() {
+        return (this._identifierType !== UaNodeIdType.NUMERIC) ? this._value : "";
+    }
+    isEmpty() {
+        return (0 === this._value) ? true : false;
+    }
+    equal(other) {
+        if (null == other)
+            return false;
+        if (this._identifierType !== other._identifierType)
+            return false;
+        if (this._nsIndex !== other._nsIndex)
+            return false;
+        if (this._value !== other._value)
+            return false;
+        return true;
+    }
+    toString() {
+        const namespacePart = (this._nsIndex == 0) ? "" : `ns=${this._nsIndex};`;
+        let str;
+        switch (this.identifierType) {
+            case UaNodeIdType.NUMERIC:
+                str = `${namespacePart}i=${this._value}`;
+                break;
+            case UaNodeIdType.STRING:
+                str = `${namespacePart}s=${this._value}`;
+                break;
+            case UaNodeIdType.GUID:
+                str = `${namespacePart}g=${this._value}`;
+                break;
+            default:
+                str = `${namespacePart}b=${this._value}`;
+                break;
+        }
+        return str;
+    }
+}
+exports.UaNodeId = UaNodeId;
+UaNodeId.nullNodeId = new UaNodeId(0, 0);
+const regexNamespaceI = /ns=([0-9]+);i=([0-9]+)/;
+const regexNamespaceS = /ns=([0-9]+);s=(.*)/;
+const regexNamespaceB = /ns=([0-9]+);b=(.*)/;
+const regexNamespaceG = /ns=([0-9]+);g=([0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12})/;
+function parseUaNodeId(value) {
+    if (value.length <= 2)
+        throw new _1.UaError((0, _1.makeUaStatusCode)(opcua_webapi_1.StatusCodes.BadNodeIdInvalid));
+    let identifierType = UaNodeIdType.NUMERIC;
+    let idValue;
+    let nsIndex;
+    let twoFirst = value.substring(0, 2);
+    let matches;
+    if (twoFirst === "i=") {
+        identifierType = UaNodeIdType.NUMERIC;
+        idValue = parseInt(value.substring(2), 10);
+    }
+    else if ((matches = regexNamespaceI.exec(value)) !== null) {
+        identifierType = UaNodeIdType.NUMERIC;
+        nsIndex = parseInt(matches[1], 10);
+        idValue = parseInt(matches[2], 10);
+    }
+    else if ((matches = regexNamespaceS.exec(value)) !== null) {
+        identifierType = UaNodeIdType.STRING;
+        nsIndex = parseInt(matches[1], 10);
+        idValue = matches[2];
+    }
+    else if (twoFirst === "s=") {
+        identifierType = UaNodeIdType.STRING;
+        idValue = value.substring(2);
+    }
+    else if ((matches = regexNamespaceB.exec(value)) !== null) {
+        identifierType = UaNodeIdType.BYTESTRING;
+        nsIndex = parseInt(matches[1], 10);
+        idValue = matches[2];
+    }
+    else if ((matches = regexNamespaceG.exec(value)) !== null) {
+        identifierType = UaNodeIdType.GUID;
+        nsIndex = parseInt(matches[1], 10);
+        idValue = matches[2];
+    }
+    else if (twoFirst === "b=") {
+        identifierType = UaNodeIdType.BYTESTRING;
+        idValue = value.substring(2);
+    }
+    else if (twoFirst === "g=") {
+        identifierType = UaNodeIdType.GUID;
+        idValue = value.substring(2);
+    }
+    else {
+        throw new _1.UaError((0, _1.makeUaStatusCode)(opcua_webapi_1.StatusCodes.BadNodeIdInvalid));
+    }
+    return new UaNodeId(idValue, nsIndex, identifierType);
+}
+function parseUaNodeIdOrNull(value) {
+    if (!value)
+        return null;
+    try {
+        return parseUaNodeId(value);
+    }
+    catch (e) {
+        return null;
+    }
+}

package/dist/cjs/common/types/UaQuery.d.ts

@@ -0,0 +1,11 @@
+import { UaContentFilter } from "../structure";
+import { UaQueryFilter } from "./UaQueryFilter";
+export declare class UaQuery {
+    private _filters;
+    private _orAll;
+    constructor(filters: Array<UaQueryFilter>, orAll?: boolean);
+    get filters(): UaQueryFilter[];
+    get orAll(): boolean;
+    toContentFilter(): UaContentFilter;
+    static fromContentFilter(filter: UaContentFilter): UaQuery | null;
+}

package/dist/cjs/common/types/UaQuery.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaQuery = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const structure_1 = require("../structure");
+const UaQueryFilter_1 = require("./UaQueryFilter");
+class UaQuery {
+    constructor(filters, orAll) {
+        this._filters = filters;
+        this._orAll = (orAll) ? true : false;
+    }
+    get filters() {
+        return this._filters;
+    }
+    get orAll() {
+        return this._orAll;
+    }
+    toContentFilter() {
+        let queryElements = [];
+        let notElements = [];
+        let index = 0;
+        for (let item of this.filters) {
+            queryElements.push(item.toContentFilterElement());
+            if (item.isNot) {
+                let notOperand = new structure_1.UaElementOperand(index);
+                let notElement = new structure_1.UaContentFilterElement([notOperand.toExtensionObject()], opcua_webapi_1.FilterOperator.Not);
+                notElements.push(notElement);
+            }
+            index++;
+        }
+        let elements = [];
+        elements.push(...queryElements);
+        elements.push(...notElements);
+        if (this.orAll) {
+            let orElement = new structure_1.UaContentFilterElement([], opcua_webapi_1.FilterOperator.Or);
+            elements.push(orElement);
+        }
+        let filter = new structure_1.UaContentFilter(elements);
+        return filter;
+    }
+    static fromContentFilter(filter) {
+        let queryElements = new Map;
+        let notElements = [];
+        let orAll = false;
+        let index = 0;
+        for (let item of filter.elements) {
+            if (item.operator == opcua_webapi_1.FilterOperator.Not) {
+                if (item.operands.length != 1 ||
+                    !item.operands[0].typeId.equal(structure_1.UaElementOperand.dataTypeId))
+                    return null;
+                let operand = structure_1.UaElementOperand.fromExtensionObject(item.operands[0]);
+                if (null == operand)
+                    return null;
+                notElements.push(operand.index);
+            }
+            else if (item.operator >= opcua_webapi_1.FilterOperator.Equals && item.operator <= opcua_webapi_1.FilterOperator.InList) {
+                let query = UaQueryFilter_1.UaQueryFilter.fromContentFilterElement(item);
+                if (null == query)
+                    return;
+                queryElements.set(index, query);
+            }
+            else if (item.operator == opcua_webapi_1.FilterOperator.Or) {
+                if (item.operands.length != 0)
+                    return null;
+                orAll = true;
+            }
+            else {
+                return null;
+            }
+            index++;
+        }
+        for (let item of notElements) {
+            let query = queryElements.get(item);
+            if (!query)
+                return null;
+            query.isNot = true;
+        }
+        let ret = new UaQuery(Array.from(queryElements.values()), orAll);
+        return ret;
+    }
+}
+exports.UaQuery = UaQuery;

package/dist/cjs/common/types/UaQueryFilter.d.ts

@@ -0,0 +1,27 @@
+import { UaContentFilterElement } from "../structure";
+import { UaVariant } from "./UaVariant";
+export declare enum UaQueryFilterType {
+    Equals = 0,
+    IsNull = 1,
+    GreaterThan = 2,
+    LessThan = 3,
+    GreaterThanOrEqual = 4,
+    LessThanOrEqual = 5,
+    Like = 6,
+    Between = 8,
+    InList = 9
+}
+export declare class UaQueryFilter {
+    private _fieldName;
+    private _operator;
+    private _value;
+    private _isNot;
+    constructor(fieldName: string, operator: UaQueryFilterType, value: UaVariant, isNot?: boolean);
+    get fieldName(): string;
+    get operator(): UaQueryFilterType;
+    get value(): UaVariant;
+    get isNot(): boolean;
+    set isNot(isNot: boolean);
+    toContentFilterElement(): UaContentFilterElement;
+    static fromContentFilterElement(element: UaContentFilterElement): UaQueryFilter | null;
+}

package/dist/cjs/common/types/UaQueryFilter.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaQueryFilter = exports.UaQueryFilterType = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const structure_1 = require("../structure");
+var UaQueryFilterType;
+(function (UaQueryFilterType) {
+    UaQueryFilterType[UaQueryFilterType["Equals"] = 0] = "Equals";
+    UaQueryFilterType[UaQueryFilterType["IsNull"] = 1] = "IsNull";
+    UaQueryFilterType[UaQueryFilterType["GreaterThan"] = 2] = "GreaterThan";
+    UaQueryFilterType[UaQueryFilterType["LessThan"] = 3] = "LessThan";
+    UaQueryFilterType[UaQueryFilterType["GreaterThanOrEqual"] = 4] = "GreaterThanOrEqual";
+    UaQueryFilterType[UaQueryFilterType["LessThanOrEqual"] = 5] = "LessThanOrEqual";
+    UaQueryFilterType[UaQueryFilterType["Like"] = 6] = "Like";
+    UaQueryFilterType[UaQueryFilterType["Between"] = 8] = "Between";
+    UaQueryFilterType[UaQueryFilterType["InList"] = 9] = "InList";
+})(UaQueryFilterType || (exports.UaQueryFilterType = UaQueryFilterType = {}));
+class UaQueryFilter {
+    constructor(fieldName, operator, value, isNot) {
+        this._fieldName = fieldName;
+        this._operator = operator;
+        this._value = value;
+        this._isNot = (isNot) ? true : false;
+    }
+    get fieldName() {
+        opcua_webapi_1.FilterOperator;
+        return this._fieldName;
+    }
+    get operator() {
+        return this._operator;
+    }
+    get value() {
+        return this._value;
+    }
+    get isNot() {
+        return this._isNot;
+    }
+    set isNot(isNot) {
+        this._isNot = isNot;
+    }
+    toContentFilterElement() {
+        let simpleOperand = new structure_1.UaSimpleAttributeOperand([this.fieldName]);
+        let literalOperand = new structure_1.UaLiteralOperand(this.value);
+        let operands = [
+            simpleOperand.toExtensionObject(),
+            literalOperand.toExtensionObject()
+        ];
+        let element = new structure_1.UaContentFilterElement(operands, this.operator);
+        return element;
+    }
+    static fromContentFilterElement(element) {
+        if (element.operator < UaQueryFilterType.Equals ||
+            element.operator > UaQueryFilterType.InList ||
+            element.operator == UaQueryFilterType.Like + 1)
+            return null;
+        let simpleOperand = null;
+        let literalOperand = null;
+        for (let item of element.operands) {
+            if (item.typeId.equal(structure_1.UaSimpleAttributeOperand.dataTypeId)) {
+                simpleOperand = structure_1.UaSimpleAttributeOperand.fromExtensionObject(item);
+            }
+            else if (item.typeId.equal(structure_1.UaLiteralOperand.dataTypeId)) {
+                literalOperand = structure_1.UaLiteralOperand.fromExtensionObject(item);
+            }
+        }
+        if (null == simpleOperand ||
+            0 == simpleOperand.browsePath.length ||
+            null == literalOperand)
+            return null;
+        let filter = new UaQueryFilter(simpleOperand.browsePath[0], element.operator, literalOperand.value);
+        return filter;
+    }
+}
+exports.UaQueryFilter = UaQueryFilter;

package/dist/cjs/common/types/UaRequestPatameters.d.ts

@@ -0,0 +1,11 @@
+export declare class UaClientParameters {
+    private _timeout?;
+    private _returnDiagnostics?;
+    private _auditEntryId?;
+    get timeout(): number | undefined;
+    set timeout(timeout: number);
+    get returnDiagnostics(): number | undefined;
+    set returnDiagnostics(returnDiagnostics: number);
+    get auditEntryId(): string | undefined;
+    set auditEntryId(auditEntryId: string);
+}

package/dist/cjs/common/types/UaRequestPatameters.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaClientParameters = void 0;
+class UaClientParameters {
+    get timeout() {
+        return this._timeout;
+    }
+    set timeout(timeout) {
+        if (timeout < 500) {
+            this._timeout = 500;
+        }
+        else {
+            this._timeout = this.timeout;
+        }
+    }
+    get returnDiagnostics() {
+        return this._returnDiagnostics;
+    }
+    set returnDiagnostics(returnDiagnostics) {
+        this._returnDiagnostics = returnDiagnostics;
+    }
+    get auditEntryId() {
+        return this._auditEntryId;
+    }
+    set auditEntryId(auditEntryId) {
+        this._auditEntryId = auditEntryId;
+    }
+}
+exports.UaClientParameters = UaClientParameters;

package/dist/cjs/common/types/UaServiceTypes.d.ts

@@ -0,0 +1,18 @@
+import { UaNodeId, UaLocalizedText, UaExpandedNodeId, UaVariant } from ".";
+export type UaReferenceDescriptor = {
+    nodeId: UaExpandedNodeId;
+    nodeClass: number;
+    browseName: string;
+    displayName: UaLocalizedText;
+    referenceTypeId: UaNodeId;
+    isForward: boolean;
+    typeDefinition?: UaExpandedNodeId;
+};
+export type UaBrowseResult = {
+    results: Array<UaReferenceDescriptor>;
+    continuationPoint?: string;
+};
+export type UaWriteValue = {
+    nodeId: UaNodeId;
+    value: UaVariant;
+};

package/dist/cjs/common/types/UaServiceTypes.js

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

package/dist/cjs/common/types/UaStatusCode.d.ts

@@ -0,0 +1,24 @@
+export declare class UaStatusCode {
+    private static _codesDictionary;
+    private _code;
+    constructor(code?: number);
+    get value(): number;
+    get name(): string;
+    toString(): string;
+    checkBit(mask: number): boolean;
+    /** returns true if the overflow bit is set */
+    get hasOverflowBit(): boolean;
+    /** returns true if the semanticChange bit is set */
+    get hasSemanticChangedBit(): boolean;
+    /** returns true if the structureChange bit is set */
+    get hasStructureChangedBit(): boolean;
+    equals(other: UaStatusCode): boolean;
+    isGood(): boolean;
+    isNotGood(): boolean;
+    isBad(): boolean;
+    isUncertain(): boolean;
+}
+export declare const extraStatusCodeBits: {
+    [key: string]: number;
+};
+export declare function makeUaStatusCode(code?: number): UaStatusCode;