opcjs-base 0.1.5 → 0.1.9

package/dist/index.cjs

@@ -1821,220 +1821,6 @@ var BinaryReader = class _BinaryReader {
   }
 };
 
-// src/types/xmlElement.ts
-var XmlElement = class _XmlElement {
-  /**
-   * The XML string content
-   */
-  content;
-  /**
-   * Create a new XmlElement
-   * 
-   * @param content - The XML string content
-   */
-  constructor(content = "") {
-    this.content = content;
-  }
-  /**
-   * Get the XML string content
-   * 
-   * @returns The XML string
-   */
-  toString() {
-    return this.content;
-  }
-  /**
-   * Get the length of the XML string
-   * 
-   * @returns The number of characters
-   */
-  get length() {
-    return this.content.length;
-  }
-  /**
-   * Validate if this XmlElement contains valid XML
-   * 
-   * Note: This is a simple check, not a full XML validator.
-   * For production use, consider using a proper XML parser.
-   * 
-   * @returns true if the string appears to be valid XML
-   * 
-   * @example
-   * ```typescript
-   * const xml = new XmlElement("<root></root>");
-   * xml.isValid(); // true
-   * ```
-   */
-  isValid() {
-    if (this.content.length === 0) {
-      return false;
-    }
-    const trimmed = this.content.trim();
-    if (!trimmed.startsWith("<") || !trimmed.endsWith(">")) {
-      return false;
-    }
-    try {
-      if (typeof globalThis !== "undefined" && "DOMParser" in globalThis) {
-        const DOMParserConstructor = globalThis.DOMParser;
-        const parser = new DOMParserConstructor();
-        const doc = parser.parseFromString(this.content, "text/xml");
-        const parserError = doc.querySelector("parsererror");
-        return parserError === null;
-      }
-    } catch {
-    }
-    return _XmlElement.checkBasicXmlStructure(trimmed);
-  }
-  /**
-   * Basic XML structure validation (for Node.js environment)
-   * Checks for matching opening and closing tags
-   */
-  static checkBasicXmlStructure(xml) {
-    const tagStack = [];
-    const tagRegex = /<\/?([a-zA-Z][\w:-]*)[^>]*>/g;
-    let match;
-    while ((match = tagRegex.exec(xml)) !== null) {
-      const fullTag = match[0];
-      const tagName = match[1];
-      if (fullTag.startsWith("</")) {
-        if (tagStack.length === 0 || tagStack.pop() !== tagName) {
-          return false;
-        }
-      } else if (!fullTag.endsWith("/>")) {
-        tagStack.push(tagName);
-      }
-    }
-    return tagStack.length === 0;
-  }
-  /**
-   * Escape special XML characters in text content
-   * 
-   * @param text - Text to escape
-   * @returns Escaped text safe for use in XML
-   * 
-   * @example
-   * ```typescript
-   * XmlElement.escape("Hello & <World>"); // "Hello &amp; &lt;World&gt;"
-   * ```
-   */
-  static escape(text) {
-    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-  }
-  /**
-   * Unescape XML entities to plain text
-   * 
-   * @param xml - XML text with entities
-   * @returns Unescaped text
-   * 
-   * @example
-   * ```typescript
-   * XmlElement.unescape("Hello &amp; &lt;World&gt;"); // "Hello & <World>"
-   * ```
-   */
-  static unescape(xml) {
-    return xml.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
-  }
-  /**
-   * Create a simple XML element
-   * 
-   * @param tagName - The XML tag name
-   * @param content - The text content (will be escaped)
-   * @param attributes - Optional attributes object
-   * @returns XmlElement
-   * 
-   * @example
-   * ```typescript
-   * const xml = XmlElement.create("Temperature", "25.5", { unit: "C" });
-   * // "<Temperature unit=\"C\">25.5</Temperature>"
-   * ```
-   */
-  static create(tagName, content = "", attributes) {
-    let attrStr = "";
-    if (attributes) {
-      attrStr = Object.entries(attributes).map(([key, value]) => ` ${key}="${_XmlElement.escape(value)}"`).join("");
-    }
-    const escapedContent = _XmlElement.escape(content);
-    const xmlString = `<${tagName}${attrStr}>${escapedContent}</${tagName}>`;
-    return new _XmlElement(xmlString);
-  }
-  /**
-   * Create an empty XmlElement
-   * 
-   * @returns Empty XmlElement
-   */
-  static empty() {
-    return new _XmlElement("");
-  }
-  /**
-   * Check equality with another XmlElement
-   * 
-   * @param other - The other XmlElement
-   * @returns true if both contain the same XML string
-   */
-  equals(other) {
-    return this.content === other.content;
-  }
-};
-
-// src/types/primitives.ts
-var BuiltinTypeId = {
-  Boolean: 1,
-  SByte: 2,
-  Byte: 3,
-  Int16: 4,
-  UInt16: 5,
-  Int32: 6,
-  UInt32: 7,
-  Int64: 8,
-  UInt64: 9,
-  Float: 10,
-  Double: 11,
-  String: 12,
-  DateTime: 13,
-  Guid: 14,
-  ByteString: 15,
-  XmlElement: 16,
-  NodeId: 17,
-  ExpandedNodeId: 18,
-  StatusCode: 19,
-  QualifiedName: 20,
-  LocalizedText: 21,
-  ExtensionObject: 22,
-  DataValue: 23,
-  Variant: 24,
-  DiagnosticInfo: 25
-};
-function getPrimitiveTypeName(typeId) {
-  const primitiveMap = {
-    [BuiltinTypeId.Boolean]: "boolean",
-    [BuiltinTypeId.SByte]: "number",
-    [BuiltinTypeId.Byte]: "number",
-    [BuiltinTypeId.Int16]: "number",
-    [BuiltinTypeId.UInt16]: "number",
-    [BuiltinTypeId.Int32]: "number",
-    [BuiltinTypeId.UInt32]: "number",
-    [BuiltinTypeId.Int64]: "bigint",
-    [BuiltinTypeId.UInt64]: "bigint",
-    [BuiltinTypeId.Float]: "number",
-    [BuiltinTypeId.ByteString]: "Uint8Array | null",
-    [BuiltinTypeId.Double]: "number",
-    [BuiltinTypeId.String]: "string | null",
-    [BuiltinTypeId.DateTime]: "Date",
-    [BuiltinTypeId.Guid]: "string"
-  };
-  return primitiveMap[typeId];
-}
-function isPrimitive(typeId) {
-  return getPrimitiveTypeName(typeId) !== void 0;
-}
-
-// src/certificates/certificate.ts
-var Certificate = class {
-  getBytes() {
-    throw new Error("Method not implemented.");
-  }
-};
-
 // src/codecs/binary/binaryWriter.ts
 var EPOCH_DIFF_MS2 = 11644473600000n;
 var TICKS_PER_MS2 = 10000n;
@@ -2093,7 +1879,9 @@ var VariantMask2 = {
 };
 var BinaryWriter = class {
   buffer;
+  view;
   position;
+  growthFactor = 2;
   getData() {
     return this.buffer.subarray(0, this.position);
   }
@@ -2137,23 +1925,25 @@ var BinaryWriter = class {
     if (!Number.isInteger(value) || value < 0 || value > 4294967295) {
       throw new CodecError(`UInt32 value ${value} out of range [0, 4294967295]`);
     }
-    this.buffer.writeUInt32LE(value, offset);
+    this.view.setUint32(offset, value, true);
   }
   /**
    * Ensure buffer has enough capacity, growing if necessary.
    */
   ensureCapacity(additionalBytes) {
-    const required = this.position + additionalBytes;
-    if (required > this.buffer.length) {
-      const newSize = Math.max(required, this.buffer.length * 2);
-      const newBuffer = Buffer.allocUnsafe(newSize);
-      this.buffer.copy(newBuffer, 0, 0, this.position);
+    const requiredSize = this.position + additionalBytes;
+    if (requiredSize > this.buffer.length) {
+      const newSize = Math.max(this.buffer.length * this.growthFactor, requiredSize);
+      const newBuffer = new Uint8Array(newSize);
+      newBuffer.set(this.buffer.subarray(0, this.position), 0);
       this.buffer = newBuffer;
+      this.view = new DataView(newBuffer.buffer, newBuffer.byteOffset, newBuffer.byteLength);
+      console.log(`BufferWriter: resized buffer to ${newSize} bytes`);
     }
   }
   writeBoolean(value) {
     this.ensureCapacity(1);
-    this.buffer.writeUInt8(value ? 1 : 0, this.position);
+    this.view.setUint8(this.position, value ? 1 : 0);
     this.position += 1;
   }
   writeByte(value) {
@@ -2161,7 +1951,7 @@ var BinaryWriter = class {
       throw new CodecError(`Byte value ${value} out of range [0, 255]`);
     }
     this.ensureCapacity(1);
-    this.buffer.writeUInt8(value, this.position);
+    this.view.setUint8(this.position, value);
     this.position += 1;
   }
   writeSByte(value) {
@@ -2169,7 +1959,7 @@ var BinaryWriter = class {
       throw new CodecError(`SByte value ${value} out of range [-128, 127]`);
     }
     this.ensureCapacity(1);
-    this.buffer.writeInt8(value, this.position);
+    this.view.setInt8(this.position, value);
     this.position += 1;
   }
   writeInt16(value) {
@@ -2177,7 +1967,7 @@ var BinaryWriter = class {
       throw new CodecError(`Int16 value ${value} out of range [-32768, 32767]`);
     }
     this.ensureCapacity(2);
-    this.buffer.writeInt16LE(value, this.position);
+    this.view.setInt16(this.position, value, true);
     this.position += 2;
   }
   writeUInt16(value) {
@@ -2185,7 +1975,7 @@ var BinaryWriter = class {
       throw new CodecError(`UInt16 value ${value} out of range [0, 65535]`);
     }
     this.ensureCapacity(2);
-    this.buffer.writeUInt16LE(value, this.position);
+    this.view.setUint16(this.position, value, true);
     this.position += 2;
   }
   writeInt32(value) {
@@ -2193,7 +1983,7 @@ var BinaryWriter = class {
       throw new CodecError(`Int32 value ${value} out of range [-2147483648, 2147483647]`);
     }
     this.ensureCapacity(4);
-    this.buffer.writeInt32LE(value, this.position);
+    this.view.setInt32(this.position, value, true);
     this.position += 4;
   }
   writeUInt32(value) {
@@ -2201,27 +1991,27 @@ var BinaryWriter = class {
       throw new CodecError(`UInt32 value ${value} out of range [0, 4294967295]`);
     }
     this.ensureCapacity(4);
-    this.buffer.writeUInt32LE(value, this.position);
+    this.view.setUint32(this.position, value, true);
     this.position += 4;
   }
   writeInt64(value) {
     this.ensureCapacity(8);
-    this.buffer.writeBigInt64LE(value, this.position);
+    this.view.setBigInt64(this.position, value, true);
     this.position += 8;
   }
   writeUInt64(value) {
     this.ensureCapacity(8);
-    this.buffer.writeBigUInt64LE(value, this.position);
+    this.view.setBigUint64(this.position, value, true);
     this.position += 8;
   }
   writeFloat(value) {
     this.ensureCapacity(4);
-    this.buffer.writeFloatLE(value, this.position);
+    this.view.setFloat32(this.position, value, true);
     this.position += 4;
   }
   writeDouble(value) {
     this.ensureCapacity(8);
-    this.buffer.writeDoubleLE(value, this.position);
+    this.view.setFloat64(this.position, value, true);
     this.position += 8;
   }
   writeString(value) {
@@ -2254,14 +2044,14 @@ var BinaryWriter = class {
     }
     this.ensureCapacity(16);
     const data1 = parseInt(hex.substr(0, 8), 16);
-    this.buffer.writeUInt32LE(data1, this.position);
+    this.view.setUint32(this.position, data1, true);
     const data2 = parseInt(hex.substr(8, 4), 16);
-    this.buffer.writeUInt16LE(data2, this.position + 4);
+    this.view.setUint16(this.position + 4, data2, true);
     const data3 = parseInt(hex.substr(12, 4), 16);
-    this.buffer.writeUInt16LE(data3, this.position + 6);
+    this.view.setUint16(this.position + 6, data3, true);
     for (let i = 0; i < 8; i++) {
       const byte = parseInt(hex.substr(16 + i * 2, 2), 16);
-      this.buffer.writeUInt8(byte, this.position + 8 + i);
+      this.view.setUint8(this.position + 8 + i, byte);
     }
     this.position += 16;
   }
@@ -2432,20 +2222,22 @@ var BinaryWriter = class {
     switch (value.encoding) {
       case 0 /* None */:
         break;
-      case 1 /* Binary */:
+      case 1 /* Binary */: {
         if (!value.data) {
           throw new CodecError("ExtensionObject with Binary encoding must have data");
         }
         const binaryData = encoder.encodeWithoutId(value.data, "binary");
         this.writeByteString(binaryData);
         break;
-      case 2 /* Xml */:
+      }
+      case 2 /* Xml */: {
         if (!value.data) {
           throw new CodecError("ExtensionObject with Xml encoding must have data");
         }
         const xmlString = encoder.encodeWithoutId(value.data, "xml");
         this.writeXmlElement(xmlString);
         break;
+      }
       default:
         throw new CodecError(`Invalid ExtensionObject encoding: ${value.encoding}`);
     }
@@ -2663,11 +2455,227 @@ var BinaryWriter = class {
     }
   }
   constructor(initialSize = 1024) {
-    this.buffer = Buffer.allocUnsafe(initialSize);
+    const data = Buffer.allocUnsafe(initialSize);
+    this.buffer = data;
+    this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
     this.position = 0;
   }
 };
 
+// src/types/xmlElement.ts
+var XmlElement = class _XmlElement {
+  /**
+   * The XML string content
+   */
+  content;
+  /**
+   * Create a new XmlElement
+   * 
+   * @param content - The XML string content
+   */
+  constructor(content = "") {
+    this.content = content;
+  }
+  /**
+   * Get the XML string content
+   * 
+   * @returns The XML string
+   */
+  toString() {
+    return this.content;
+  }
+  /**
+   * Get the length of the XML string
+   * 
+   * @returns The number of characters
+   */
+  get length() {
+    return this.content.length;
+  }
+  /**
+   * Validate if this XmlElement contains valid XML
+   * 
+   * Note: This is a simple check, not a full XML validator.
+   * For production use, consider using a proper XML parser.
+   * 
+   * @returns true if the string appears to be valid XML
+   * 
+   * @example
+   * ```typescript
+   * const xml = new XmlElement("<root></root>");
+   * xml.isValid(); // true
+   * ```
+   */
+  isValid() {
+    if (this.content.length === 0) {
+      return false;
+    }
+    const trimmed = this.content.trim();
+    if (!trimmed.startsWith("<") || !trimmed.endsWith(">")) {
+      return false;
+    }
+    try {
+      if (typeof globalThis !== "undefined" && "DOMParser" in globalThis) {
+        const DOMParserConstructor = globalThis.DOMParser;
+        const parser = new DOMParserConstructor();
+        const doc = parser.parseFromString(this.content, "text/xml");
+        const parserError = doc.querySelector("parsererror");
+        return parserError === null;
+      }
+    } catch {
+    }
+    return _XmlElement.checkBasicXmlStructure(trimmed);
+  }
+  /**
+   * Basic XML structure validation (for Node.js environment)
+   * Checks for matching opening and closing tags
+   */
+  static checkBasicXmlStructure(xml) {
+    const tagStack = [];
+    const tagRegex = /<\/?([a-zA-Z][\w:-]*)[^>]*>/g;
+    let match;
+    while ((match = tagRegex.exec(xml)) !== null) {
+      const fullTag = match[0];
+      const tagName = match[1];
+      if (fullTag.startsWith("</")) {
+        if (tagStack.length === 0 || tagStack.pop() !== tagName) {
+          return false;
+        }
+      } else if (!fullTag.endsWith("/>")) {
+        tagStack.push(tagName);
+      }
+    }
+    return tagStack.length === 0;
+  }
+  /**
+   * Escape special XML characters in text content
+   * 
+   * @param text - Text to escape
+   * @returns Escaped text safe for use in XML
+   * 
+   * @example
+   * ```typescript
+   * XmlElement.escape("Hello & <World>"); // "Hello &amp; &lt;World&gt;"
+   * ```
+   */
+  static escape(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  }
+  /**
+   * Unescape XML entities to plain text
+   * 
+   * @param xml - XML text with entities
+   * @returns Unescaped text
+   * 
+   * @example
+   * ```typescript
+   * XmlElement.unescape("Hello &amp; &lt;World&gt;"); // "Hello & <World>"
+   * ```
+   */
+  static unescape(xml) {
+    return xml.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+  }
+  /**
+   * Create a simple XML element
+   * 
+   * @param tagName - The XML tag name
+   * @param content - The text content (will be escaped)
+   * @param attributes - Optional attributes object
+   * @returns XmlElement
+   * 
+   * @example
+   * ```typescript
+   * const xml = XmlElement.create("Temperature", "25.5", { unit: "C" });
+   * // "<Temperature unit=\"C\">25.5</Temperature>"
+   * ```
+   */
+  static create(tagName, content = "", attributes) {
+    let attrStr = "";
+    if (attributes) {
+      attrStr = Object.entries(attributes).map(([key, value]) => ` ${key}="${_XmlElement.escape(value)}"`).join("");
+    }
+    const escapedContent = _XmlElement.escape(content);
+    const xmlString = `<${tagName}${attrStr}>${escapedContent}</${tagName}>`;
+    return new _XmlElement(xmlString);
+  }
+  /**
+   * Create an empty XmlElement
+   * 
+   * @returns Empty XmlElement
+   */
+  static empty() {
+    return new _XmlElement("");
+  }
+  /**
+   * Check equality with another XmlElement
+   * 
+   * @param other - The other XmlElement
+   * @returns true if both contain the same XML string
+   */
+  equals(other) {
+    return this.content === other.content;
+  }
+};
+
+// src/types/primitives.ts
+var BuiltinTypeId = {
+  Boolean: 1,
+  SByte: 2,
+  Byte: 3,
+  Int16: 4,
+  UInt16: 5,
+  Int32: 6,
+  UInt32: 7,
+  Int64: 8,
+  UInt64: 9,
+  Float: 10,
+  Double: 11,
+  String: 12,
+  DateTime: 13,
+  Guid: 14,
+  ByteString: 15,
+  XmlElement: 16,
+  NodeId: 17,
+  ExpandedNodeId: 18,
+  StatusCode: 19,
+  QualifiedName: 20,
+  LocalizedText: 21,
+  ExtensionObject: 22,
+  DataValue: 23,
+  Variant: 24,
+  DiagnosticInfo: 25
+};
+function getPrimitiveTypeName(typeId) {
+  const primitiveMap = {
+    [BuiltinTypeId.Boolean]: "boolean",
+    [BuiltinTypeId.SByte]: "number",
+    [BuiltinTypeId.Byte]: "number",
+    [BuiltinTypeId.Int16]: "number",
+    [BuiltinTypeId.UInt16]: "number",
+    [BuiltinTypeId.Int32]: "number",
+    [BuiltinTypeId.UInt32]: "number",
+    [BuiltinTypeId.Int64]: "bigint",
+    [BuiltinTypeId.UInt64]: "bigint",
+    [BuiltinTypeId.Float]: "number",
+    [BuiltinTypeId.ByteString]: "Uint8Array | null",
+    [BuiltinTypeId.Double]: "number",
+    [BuiltinTypeId.String]: "string | null",
+    [BuiltinTypeId.DateTime]: "Date",
+    [BuiltinTypeId.Guid]: "string"
+  };
+  return primitiveMap[typeId];
+}
+function isPrimitive(typeId) {
+  return getPrimitiveTypeName(typeId) !== void 0;
+}
+
+// src/certificates/certificate.ts
+var Certificate = class {
+  getBytes() {
+    throw new Error("Method not implemented.");
+  }
+};
+
 // src/schema/enums.ts
 var ActionStateEnum = /* @__PURE__ */ ((ActionStateEnum2) => {
   ActionStateEnum2[ActionStateEnum2["Idle"] = 0] = "Idle";
@@ -17056,6 +17064,7 @@ exports.AxisScaleEnumerationEnum = AxisScaleEnumerationEnum;
 exports.BaseConfigurationDataType = BaseConfigurationDataType;
 exports.BaseConfigurationRecordDataType = BaseConfigurationRecordDataType;
 exports.BinaryReader = BinaryReader;
+exports.BinaryWriter = BinaryWriter;
 exports.BitFieldDefinition = BitFieldDefinition;
 exports.BrokerConnectionTransportDataType = BrokerConnectionTransportDataType;
 exports.BrokerDataSetReaderTransportDataType = BrokerDataSetReaderTransportDataType;