opcjs-base 0.1.34-alpha → 0.1.36-alpha

package/dist/index.d.cts

@@ -1197,14 +1197,30 @@ declare class Variant {
      */
     toString(): string;
     /**
-     * Union of all OPC UA built-in types accepted by {@link Variant.newFrom}.
+     * Creates a {@link Variant} from any OPC UA built-in scalar value or a
+     * homogeneous array of such values.
      *
-     * Includes both the tagged numeric primitives from `UaPrimitive` (which carry
-     * a `BuiltInType` discriminant so the exact numeric encoding is known) and the
-     * class-based built-in types that are identified unambiguously at runtime via
-     * `instanceof`.
+     * **Scalar usage** — pass any concrete OPC UA type and the BuiltInType is
+     * inferred automatically:
+     * ```ts
+     * Variant.newFrom('hello')              // String
+     * Variant.newFrom(uaDouble(3.14))       // Double
+     * Variant.newFrom(new LocalizedText('en', 'Hi'))
+     * ```
+     *
+     * **Array usage** — pass a plain JS array of a single homogeneous element type:
+     * ```ts
+     * Variant.newFrom([uaDouble(1.0), uaDouble(2.0)])          // Double[]
+     * Variant.newFrom([new LocalizedText('en', 'A'), ...])     // LocalizedText[]
+     * ```
+     *
+     * Throws if the array is empty (element type cannot be inferred), if the
+     * first element is null/undefined, or if elements have mixed types.
+     *
+     * Note: `Variant` itself is excluded from the accepted types intentionally —
+     * callers should work with concrete OPC UA types.
      */
-    static newFrom(value: UaPrimitive | NodeId | ExpandedNodeId | QualifiedName | LocalizedText | XmlElement | ExtensionObject | DataValue | DiagnosticInfo | Variant | null | undefined): Variant;
+    static newFrom(value: UaPrimitive | NodeId | ExpandedNodeId | QualifiedName | LocalizedText | XmlElement | ExtensionObject | DataValue | DiagnosticInfo | null | undefined | UaPrimitive[] | NodeId[] | ExpandedNodeId[] | QualifiedName[] | LocalizedText[] | XmlElement[] | ExtensionObject[] | DataValue[] | DiagnosticInfo[]): Variant;
     /**
      * Creates a undefined variant.
      *

package/dist/index.d.ts

@@ -1197,14 +1197,30 @@ declare class Variant {
      */
     toString(): string;
     /**
-     * Union of all OPC UA built-in types accepted by {@link Variant.newFrom}.
+     * Creates a {@link Variant} from any OPC UA built-in scalar value or a
+     * homogeneous array of such values.
      *
-     * Includes both the tagged numeric primitives from `UaPrimitive` (which carry
-     * a `BuiltInType` discriminant so the exact numeric encoding is known) and the
-     * class-based built-in types that are identified unambiguously at runtime via
-     * `instanceof`.
+     * **Scalar usage** — pass any concrete OPC UA type and the BuiltInType is
+     * inferred automatically:
+     * ```ts
+     * Variant.newFrom('hello')              // String
+     * Variant.newFrom(uaDouble(3.14))       // Double
+     * Variant.newFrom(new LocalizedText('en', 'Hi'))
+     * ```
+     *
+     * **Array usage** — pass a plain JS array of a single homogeneous element type:
+     * ```ts
+     * Variant.newFrom([uaDouble(1.0), uaDouble(2.0)])          // Double[]
+     * Variant.newFrom([new LocalizedText('en', 'A'), ...])     // LocalizedText[]
+     * ```
+     *
+     * Throws if the array is empty (element type cannot be inferred), if the
+     * first element is null/undefined, or if elements have mixed types.
+     *
+     * Note: `Variant` itself is excluded from the accepted types intentionally —
+     * callers should work with concrete OPC UA types.
      */
-    static newFrom(value: UaPrimitive | NodeId | ExpandedNodeId | QualifiedName | LocalizedText | XmlElement | ExtensionObject | DataValue | DiagnosticInfo | Variant | null | undefined): Variant;
+    static newFrom(value: UaPrimitive | NodeId | ExpandedNodeId | QualifiedName | LocalizedText | XmlElement | ExtensionObject | DataValue | DiagnosticInfo | null | undefined | UaPrimitive[] | NodeId[] | ExpandedNodeId[] | QualifiedName[] | LocalizedText[] | XmlElement[] | ExtensionObject[] | DataValue[] | DiagnosticInfo[]): Variant;
     /**
      * Creates a undefined variant.
      *

package/dist/index.js

@@ -1862,6 +1862,25 @@ var DiagnosticInfo = class _DiagnosticInfo {
 };
 
 // src/types/variant.ts
+function inferBuiltInType(element) {
+  if (typeof element === "boolean") return { type: 1 /* Boolean */, rawValue: element };
+  if (typeof element === "string") return { type: 12 /* String */, rawValue: element };
+  if (element instanceof Uint8Array) return { type: 15 /* ByteString */, rawValue: element };
+  if (element instanceof Date) return { type: 13 /* DateTime */, rawValue: element };
+  if (element instanceof ExpandedNodeId) return { type: 18 /* ExpandedNodeId */, rawValue: element };
+  if (element instanceof NodeId) return { type: 17 /* NodeId */, rawValue: element };
+  if (element instanceof QualifiedName) return { type: 20 /* QualifiedName */, rawValue: element };
+  if (element instanceof LocalizedText) return { type: 21 /* LocalizedText */, rawValue: element };
+  if (element instanceof XmlElement) return { type: 16 /* XmlElement */, rawValue: element };
+  if (element instanceof ExtensionObject) return { type: 22 /* ExtensionObject */, rawValue: element };
+  if (element instanceof DataValue) return { type: 23 /* DataValue */, rawValue: element };
+  if (element instanceof DiagnosticInfo) return { type: 25 /* DiagnosticInfo */, rawValue: element };
+  if (typeof element === "object" && element !== null && "type" in element) {
+    const tagged = element;
+    return { type: tagged.type, rawValue: tagged.value };
+  }
+  throw new Error(`newFrom: unhandled array element: ${JSON.stringify(element)}`);
+}
 var Variant = class _Variant {
   /**
    * The variant type identifier.
@@ -1954,14 +1973,55 @@ var Variant = class _Variant {
     return `Variant(${typeName}: ${String(this.value)})`;
   }
   /**
-   * Union of all OPC UA built-in types accepted by {@link Variant.newFrom}.
+   * Creates a {@link Variant} from any OPC UA built-in scalar value or a
+   * homogeneous array of such values.
+   *
+   * **Scalar usage** — pass any concrete OPC UA type and the BuiltInType is
+   * inferred automatically:
+   * ```ts
+   * Variant.newFrom('hello')              // String
+   * Variant.newFrom(uaDouble(3.14))       // Double
+   * Variant.newFrom(new LocalizedText('en', 'Hi'))
+   * ```
+   *
+   * **Array usage** — pass a plain JS array of a single homogeneous element type:
+   * ```ts
+   * Variant.newFrom([uaDouble(1.0), uaDouble(2.0)])          // Double[]
+   * Variant.newFrom([new LocalizedText('en', 'A'), ...])     // LocalizedText[]
+   * ```
+   *
+   * Throws if the array is empty (element type cannot be inferred), if the
+   * first element is null/undefined, or if elements have mixed types.
    *
-   * Includes both the tagged numeric primitives from `UaPrimitive` (which carry
-   * a `BuiltInType` discriminant so the exact numeric encoding is known) and the
-   * class-based built-in types that are identified unambiguously at runtime via
-   * `instanceof`.
+   * Note: `Variant` itself is excluded from the accepted types intentionally —
+   * callers should work with concrete OPC UA types.
    */
   static newFrom(value) {
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        throw new Error(
+          "newFrom: cannot create an array Variant from an empty array \u2014 the element type cannot be inferred. Use new Variant(type, []) directly."
+        );
+      }
+      const firstElement = value[0];
+      if (firstElement === null || firstElement === void 0) {
+        throw new Error(
+          "newFrom: the first array element must not be null or undefined \u2014 the element type cannot be inferred."
+        );
+      }
+      const { type } = inferBuiltInType(firstElement);
+      const rawValues = value.map((el, index) => {
+        if (el === null || el === void 0) return el;
+        const { type: elType, rawValue } = inferBuiltInType(el);
+        if (elType !== type) {
+          throw new Error(
+            `newFrom: mixed-type arrays are not supported. Expected ${BuiltInType[type]} but got ${BuiltInType[elType]} at index ${index}.`
+          );
+        }
+        return rawValue;
+      });
+      return new _Variant(type, rawValues);
+    }
     if (value === null || value === void 0) {
       return _Variant.newNull();
     }
@@ -2001,9 +2061,6 @@ var Variant = class _Variant {
     if (value instanceof DiagnosticInfo) {
       return new _Variant(25 /* DiagnosticInfo */, value);
     }
-    if (value instanceof _Variant) {
-      return new _Variant(24 /* Variant */, value);
-    }
     if (typeof value === "object" && "type" in value) {
       const tagged = value;
       return new _Variant(tagged.type, tagged.value);
@@ -17853,6 +17910,7 @@ var SecureChannelMessageDecoder = class extends TransformStream {
         this.logger.warn("SecureChannel received Abort message");
         const secHeader = MsgSecurityHeaderSymmetric.decode(buffer);
         const msgSym = MsgSymmetric.decode(buffer, header, secHeader, this.context.securityAlgorithm);
+        if (!this.validateSequenceNumber(msgSym.sequenceHeader.sequenceNumber, controller)) return;
         controller.enqueue(msgSym);
         break;
       }