node-opcua-variant 2.98.0 → 2.99.0

package/dist/DataType_enum.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @module node-opcua-variant
+ */
+import { Enum } from "node-opcua-enum";
+export { DataType } from "node-opcua-basic-types";
+export declare const _enumerationDataType: Enum;

package/dist/DataType_enum.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._enumerationDataType = exports.DataType = void 0;
+const node_opcua_factory_1 = require("node-opcua-factory");
+const node_opcua_basic_types_1 = require("node-opcua-basic-types");
+var node_opcua_basic_types_2 = require("node-opcua-basic-types");
+Object.defineProperty(exports, "DataType", { enumerable: true, get: function () { return node_opcua_basic_types_2.DataType; } });
+const schemaDataType = {
+    name: "DataType",
+    enumValues: node_opcua_basic_types_1.DataType
+};
+exports._enumerationDataType = (0, node_opcua_factory_1.registerEnumeration)(schemaDataType);
+//# sourceMappingURL=DataType_enum.js.map

package/dist/DataType_enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataType_enum.js","sourceRoot":"","sources":["../source/DataType_enum.ts"],"names":[],"mappings":";;;AAIA,2DAAyD;AACzD,mEAAkD;AAClD,iEAAkD;AAAzC,kHAAA,QAAQ,OAAA;AACjB,MAAM,cAAc,GAAG;IACnB,IAAI,EAAE,UAAU;IAEhB,UAAU,EAAE,iCAAQ;CACvB,CAAC;AACW,QAAA,oBAAoB,GAAS,IAAA,wCAAmB,EAAC,cAAc,CAAC,CAAC"}

package/dist/VariantArrayType_enum.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module node-opcua-variant
+ */
+import { Enum } from "node-opcua-enum";
+export declare enum VariantArrayType {
+    Scalar = 0,
+    Array = 1,
+    Matrix = 2
+}
+/***
+ * @private
+ */
+export declare const _enumerationVariantArrayType: Enum;

package/dist/VariantArrayType_enum.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._enumerationVariantArrayType = exports.VariantArrayType = void 0;
+const node_opcua_factory_1 = require("node-opcua-factory");
+var VariantArrayType;
+(function (VariantArrayType) {
+    VariantArrayType[VariantArrayType["Scalar"] = 0] = "Scalar";
+    VariantArrayType[VariantArrayType["Array"] = 1] = "Array";
+    VariantArrayType[VariantArrayType["Matrix"] = 2] = "Matrix";
+})(VariantArrayType = exports.VariantArrayType || (exports.VariantArrayType = {}));
+const schemaVariantArrayType = {
+    enumValues: VariantArrayType,
+    name: "VariantArrayType"
+};
+/***
+ * @private
+ */
+exports._enumerationVariantArrayType = (0, node_opcua_factory_1.registerEnumeration)(schemaVariantArrayType);
+//# sourceMappingURL=VariantArrayType_enum.js.map

package/dist/VariantArrayType_enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VariantArrayType_enum.js","sourceRoot":"","sources":["../source/VariantArrayType_enum.ts"],"names":[],"mappings":";;;AAIA,2DAAyD;AAEzD,IAAY,gBAIX;AAJD,WAAY,gBAAgB;IACxB,2DAAa,CAAA;IACb,yDAAY,CAAA;IACZ,2DAAa,CAAA;AACjB,CAAC,EAJW,gBAAgB,GAAhB,wBAAgB,KAAhB,wBAAgB,QAI3B;AAED,MAAM,sBAAsB,GAAG;IAC3B,UAAU,EAAE,gBAAgB;IAC5B,IAAI,EAAE,kBAAkB;CAC3B,CAAC;AAEF;;GAEG;AACU,QAAA,4BAA4B,GAAS,IAAA,wCAAmB,EAAC,sBAAsB,CAAC,CAAC"}

package/dist/adjust_variant.d.ts

@@ -0,0 +1,3 @@
+import { Variant } from "./variant";
+import { DataType } from "./DataType_enum";
+export declare function adjustVariant(variant: Variant, valueRank: number, targetDataType: DataType): Variant;

package/dist/adjust_variant.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adjustVariant = void 0;
+const node_opcua_assert_1 = require("node-opcua-assert");
+const DataType_enum_1 = require("./DataType_enum");
+const VariantArrayType_enum_1 = require("./VariantArrayType_enum");
+function adjustVariant(variant, valueRank, targetDataType) {
+    if (targetDataType === DataType_enum_1.DataType.Byte && valueRank === 1 /* Array */) {
+        if (variant.arrayType === VariantArrayType_enum_1.VariantArrayType.Scalar && variant.dataType === DataType_enum_1.DataType.ByteString) {
+            // Byte
+            variant.arrayType = VariantArrayType_enum_1.VariantArrayType.Array;
+            variant.dataType = DataType_enum_1.DataType.Byte;
+            (0, node_opcua_assert_1.default)(variant.dataType === DataType_enum_1.DataType.Byte);
+            (0, node_opcua_assert_1.default)(!variant.value || variant.value instanceof Buffer);
+        }
+    }
+    if (targetDataType === DataType_enum_1.DataType.ByteString && valueRank === -1 /* Scalar*/) {
+        if (variant.arrayType === VariantArrayType_enum_1.VariantArrayType.Array && variant.dataType === DataType_enum_1.DataType.Byte) {
+            // Byte
+            variant.arrayType = VariantArrayType_enum_1.VariantArrayType.Scalar;
+            variant.dataType = DataType_enum_1.DataType.ByteString;
+            (0, node_opcua_assert_1.default)(variant.dataType === DataType_enum_1.DataType.ByteString);
+            (0, node_opcua_assert_1.default)(!variant.value || variant.value instanceof Buffer);
+        }
+    }
+    return variant;
+}
+exports.adjustVariant = adjustVariant;
+//# sourceMappingURL=adjust_variant.js.map

package/dist/adjust_variant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adjust_variant.js","sourceRoot":"","sources":["../source/adjust_variant.ts"],"names":[],"mappings":";;;AAAA,yDAAuC;AAEvC,mDAA2C;AAC3C,mEAA2D;AAE3D,SAAgB,aAAa,CAAC,OAAgB,EAAE,SAAiB,EAAE,cAAwB;IACvF,IAAI,cAAc,KAAK,wBAAQ,CAAC,IAAI,IAAI,SAAS,KAAK,CAAC,CAAC,WAAW,EAAE;QACjE,IAAI,OAAO,CAAC,SAAS,KAAK,wCAAgB,CAAC,MAAM,IAAI,OAAO,CAAC,QAAQ,KAAK,wBAAQ,CAAC,UAAU,EAAE;YAC3F,OAAO;YACP,OAAO,CAAC,SAAS,GAAG,wCAAgB,CAAC,KAAK,CAAC;YAC3C,OAAO,CAAC,QAAQ,GAAG,wBAAQ,CAAC,IAAI,CAAC;YACjC,IAAA,2BAAM,EAAC,OAAO,CAAC,QAAQ,KAAK,wBAAQ,CAAC,IAAI,CAAC,CAAC;YAC3C,IAAA,2BAAM,EAAC,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,YAAY,MAAM,CAAC,CAAC;SAC7D;KACJ;IACD,IAAI,cAAc,KAAK,wBAAQ,CAAC,UAAU,IAAI,SAAS,KAAK,CAAC,CAAC,CAAC,WAAW,EAAE;QACxE,IAAI,OAAO,CAAC,SAAS,KAAK,wCAAgB,CAAC,KAAK,IAAI,OAAO,CAAC,QAAQ,KAAK,wBAAQ,CAAC,IAAI,EAAE;YACpF,OAAO;YACP,OAAO,CAAC,SAAS,GAAG,wCAAgB,CAAC,MAAM,CAAC;YAC5C,OAAO,CAAC,QAAQ,GAAG,wBAAQ,CAAC,UAAU,CAAC;YACvC,IAAA,2BAAM,EAAC,OAAO,CAAC,QAAQ,KAAK,wBAAQ,CAAC,UAAU,CAAC,CAAC;YACjD,IAAA,2BAAM,EAAC,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,YAAY,MAAM,CAAC,CAAC;SAC7D;KACJ;IACD,OAAO,OAAO,CAAC;AACnB,CAAC;AApBD,sCAoBC"}

package/dist/cast_variant.d.ts

@@ -0,0 +1,22 @@
+export {};
+/**
+ * cast the variant value to match the type required by the variable
+ * - the method will throw if no conversion is possible
+ * - the original variant will not be modified if it already has the required type
+ * - the variant will be modified accordingly to match the required type
+ *
+ * | ....    | Byte | UInt16 | UInt32 | UInt64 | Boolean | SByte | Int16 | Int32  | Int64 | Float | Double | String | anything else |
+ * | ------- | ---- | ------ | ------ | ------ | ------- | ----- | ----- | ------ | ----- | ----- | ------ | ------ | ------------- |
+ * | Byte    |   -  | OK     | OK     | OK     | F=0;T<>0| <128  | OK    | OK     | OK    | OK    | OK     |        |               |
+ * | UInt16  |<=255 | -      | OK     | OK     | F=0;T<>0| <128  |<2^15-1| OK     | OK    | OK    | OK     |        |               |
+ * | UInt32  |<=255 |<2^16   | -      | OK     | F=0;T<>0| <128  |<2^15-1| <2^31-1| OK    | OK    | OK     |        |               |
+ * | UInt64  |<=255 |<2^16   |<2^31   | -      | F=0;T<>0| <128  |<2^15-1| <2^31-1| OK    | OK(*) | OK(*)  |        |               |
+ * | Boolean | x    |F=0;T=1 |F=0;T=1 | F=0;T=1| -       |F=0;T=1|F=0;T=1|F=0;T=1 |F=0;T=1|F=0;T=1|F=0;T=1 |        |               |
+ * | SByte   |>=0   | >=0    | >=0    | >=0    | F=0;T<>0| -     | OK    | OK     | OK    | OK    | OK     |        |               |
+ * | Int16   |a<x<b | >=0    | OK     | OK     | F=0;T<>0|<128   | -     | OK     | OK    | OK    | OK     |        |               |
+ * | Int32   |a<x<b |a<x<b   | >=0    | OK     | F=0;T<>0|<128   |       | -      | OK    | OK    | OK     |        |               |
+ * | Int64   |a<x<b |a<x<b   | a<x<b  | >=0    | F=0;T<>0|<128   | -     |        | -     | OK    | OK     |        |               |
+ * | Float   |err   |err     | err    | err    | F=0;T<>0| err   | err   | err    | err   | -     | OK     |        |               |
+ * | Double  |err   |err     | err    | err    | F=0;T<>0| err   | err   | err    | err   | *     | -      |        |               |
+ * | String  |err   |err     | err    | err    | err     | err   | err   | err    | err   | err   | err    | -      |               |
+ */

package/dist/cast_variant.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// TODO
+/**
+ * cast the variant value to match the type required by the variable
+ * - the method will throw if no conversion is possible
+ * - the original variant will not be modified if it already has the required type
+ * - the variant will be modified accordingly to match the required type
+ *
+ * | ....    | Byte | UInt16 | UInt32 | UInt64 | Boolean | SByte | Int16 | Int32  | Int64 | Float | Double | String | anything else |
+ * | ------- | ---- | ------ | ------ | ------ | ------- | ----- | ----- | ------ | ----- | ----- | ------ | ------ | ------------- |
+ * | Byte    |   -  | OK     | OK     | OK     | F=0;T<>0| <128  | OK    | OK     | OK    | OK    | OK     |        |               |
+ * | UInt16  |<=255 | -      | OK     | OK     | F=0;T<>0| <128  |<2^15-1| OK     | OK    | OK    | OK     |        |               |
+ * | UInt32  |<=255 |<2^16   | -      | OK     | F=0;T<>0| <128  |<2^15-1| <2^31-1| OK    | OK    | OK     |        |               |
+ * | UInt64  |<=255 |<2^16   |<2^31   | -      | F=0;T<>0| <128  |<2^15-1| <2^31-1| OK    | OK(*) | OK(*)  |        |               |
+ * | Boolean | x    |F=0;T=1 |F=0;T=1 | F=0;T=1| -       |F=0;T=1|F=0;T=1|F=0;T=1 |F=0;T=1|F=0;T=1|F=0;T=1 |        |               |
+ * | SByte   |>=0   | >=0    | >=0    | >=0    | F=0;T<>0| -     | OK    | OK     | OK    | OK    | OK     |        |               |
+ * | Int16   |a<x<b | >=0    | OK     | OK     | F=0;T<>0|<128   | -     | OK     | OK    | OK    | OK     |        |               |
+ * | Int32   |a<x<b |a<x<b   | >=0    | OK     | F=0;T<>0|<128   |       | -      | OK    | OK    | OK     |        |               |
+ * | Int64   |a<x<b |a<x<b   | a<x<b  | >=0    | F=0;T<>0|<128   | -     |        | -     | OK    | OK     |        |               |
+ * | Float   |err   |err     | err    | err    | F=0;T<>0| err   | err   | err    | err   | -     | OK     |        |               |
+ * | Double  |err   |err     | err    | err    | F=0;T<>0| err   | err   | err    | err   | *     | -      |        |               |
+ * | String  |err   |err     | err    | err    | err     | err   | err   | err    | err   | err   | err    | -      |               |
+ */
+/*
+export function castVariant(variant: Variant, targetDataType: DataType): Variant {
+    if (targetDataType !== variant.dataType) {
+        switch (targetDataType) {
+            case DataType.SByte:
+            case DataType.Int16:
+            case DataType.Int32:
+            case DataType.Int64:
+            case DataType.Byte:
+            case DataType.Int16:
+            case DataType.UInt32:
+            case DataType.UInt32:
+            case DataType.UInt64:
+            case DataType.Double:
+            case DataType.Float:
+                switch (variant.dataType) {
+                    case DataType.SByte:
+                    case DataType.Int16:
+                    case DataType.Int32:
+                    case DataType.Int64:
+                    case DataType.Byte:
+                    case DataType.UInt16:
+                    case DataType.UInt32:
+                    case DataType.UInt64:
+                    case DataType.Double:
+                    case DataType.Float:
+                        variant.dataType = targetDataType;
+                        break;
+                }
+                break;
+        }
+    }
+
+    return variant;
+}
+*/
+//# sourceMappingURL=cast_variant.js.map

package/dist/cast_variant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cast_variant.js","sourceRoot":"","sources":["../source/cast_variant.ts"],"names":[],"mappings":";;AAGA,OAAO;AACP;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCE"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @module node-opcua-variant
+ */
+export * from "./DataType_enum";
+export * from "./VariantArrayType_enum";
+export * from "./variant";
+export * from "./adjust_variant";
+export * from "./cast_variant";
+export * from "./verify_rank_and_dimension";

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @module node-opcua-variant
+ */
+__exportStar(require("./DataType_enum"), exports);
+__exportStar(require("./VariantArrayType_enum"), exports);
+__exportStar(require("./variant"), exports);
+__exportStar(require("./adjust_variant"), exports);
+__exportStar(require("./cast_variant"), exports);
+__exportStar(require("./verify_rank_and_dimension"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,kDAAgC;AAChC,0DAAwC;AACxC,4CAA0B;AAC1B,mDAAiC;AACjC,iDAA+B;AAC/B,8DAA4C"}

package/dist/variant.d.ts

@@ -0,0 +1,83 @@
+/// <reference types="node" />
+import { BaseUAObject, DecodeDebugOptions } from "node-opcua-factory";
+import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
+import { DataType } from "./DataType_enum";
+import { VariantArrayType } from "./VariantArrayType_enum";
+declare function _coerceVariant(variantLike: VariantOptions | Variant): Variant;
+export interface VariantOptions {
+    dataType?: DataType | string;
+    arrayType?: VariantArrayType | string;
+    value?: any;
+    dimensions?: number[] | null;
+}
+export interface VariantOptions2 {
+    dataType: DataType;
+    arrayType: VariantArrayType;
+    value: any;
+    dimensions: number[] | null;
+}
+export declare class Variant extends BaseUAObject {
+    static maxTypedArrayLength: number;
+    static maxArrayLength: number;
+    static schema: import("node-opcua-factory").IStructuredTypeSchema;
+    static coerce: typeof _coerceVariant;
+    static computer_default_value: () => Variant;
+    dataType: DataType;
+    arrayType: VariantArrayType;
+    value: any;
+    dimensions: number[] | null;
+    constructor(options?: VariantOptions | null);
+    encode(stream: OutputBinaryStream): void;
+    decode(stream: BinaryStream): void;
+    decodeDebug(stream: BinaryStream, options: DecodeDebugOptions): void;
+    toString(): string;
+    isValid(): boolean;
+    clone(): Variant;
+}
+export type VariantLike = VariantOptions;
+/***
+ * @private
+ */
+export declare const VARIANT_ARRAY_MASK = 128;
+/***
+ * @private
+ */
+export declare const VARIANT_ARRAY_DIMENSIONS_MASK = 64;
+/***
+ * @private
+ */
+export declare const VARIANT_TYPE_MASK = 63;
+/***
+ * @private
+ */
+export declare function encodeVariant(variant: Variant | undefined | null, stream: OutputBinaryStream): void;
+/***
+ * @private
+ */
+export declare function decodeVariant(stream: BinaryStream, value?: Variant): Variant;
+/***
+ * @private
+ */
+export type BufferedArray2 = Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array;
+export declare function coerceVariantType(dataType: DataType, value: undefined | any): any;
+export declare function isValidVariant(arrayType: VariantArrayType, dataType: DataType, value: unknown, dimensions?: number[] | null): boolean;
+export declare function buildVariantArray(dataType: DataType, nbElements: number, defaultValue: unknown): Float32Array | Float64Array | Uint32Array | Int32Array | Uint16Array | Int16Array | Uint8Array | Int8Array | Array<unknown>;
+/***
+ *  returns true if the two variant represent the same value
+ * @param v1 the first variant to compare
+ * @param v2  the variant to compare with
+ */
+export declare function sameVariant(v1: Variant, v2: Variant): boolean;
+export interface VariantOptionsT<T, DT extends DataType> extends VariantOptions {
+    dataType: DT;
+    arrayType?: VariantArrayType | string;
+    value: T;
+    dimensions?: number[] | null;
+}
+export interface VariantT<T, DT extends DataType> extends Variant {
+    value: T;
+    dataType: DT;
+}
+export declare type VariantByteString = VariantT<Buffer, DataType.ByteString>;
+export declare type VariantDouble = VariantT<number, DataType.Double>;
+export {};