opcjs-base 0.1.34-alpha → 0.1.35-alpha

package/dist/index.cjs

@@ -1864,6 +1864,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.
@@ -1956,14 +1975,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'))
+   * ```
    *
-   * 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`.
+   * **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) {
+    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();
     }
@@ -2003,9 +2063,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);