@xapi-js/core 1.0.0 → 1.1.0

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/handler.ts
-import { StaxXmlParser, StaxXmlWriter, XmlEventType } from "stax-xml";
+import { StaxXmlWriter } from "stax-xml";
+import * as txml from "txml";
 
 // src/types.ts
 var rowType = ["insert", "update", "delete"];
@@ -18,21 +19,31 @@ var ColumnTypeError = class extends Error {
     this.name = "ColumnTypeError";
   }
 };
+var InvalidXmlError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidXmlError";
+  }
+};
 
 // src/utils.ts
+function arrayBufferToString(buffer) {
+  const decoder = new TextDecoder();
+  return decoder.decode(buffer);
+}
 function makeParseEntities() {
-  const entities = [];
+  const entities2 = [];
   for (let i = 1; i <= 32; i++) {
-    entities.push({ entity: `&#${i};`, value: String.fromCharCode(i) });
+    entities2.push({ entity: `&#${i};`, value: String.fromCharCode(i) });
   }
-  return entities;
+  return entities2;
 }
 function makeWriterEntities() {
-  const entities = [];
+  const entities2 = [];
   for (let i = 1; i <= 32; i++) {
-    entities.push({ entity: `&#${i};`, value: String.fromCharCode(i) });
+    entities2.push({ entity: `&#${i};`, value: String.fromCharCode(i) });
   }
-  return entities;
+  return entities2;
 }
 function base64ToUint8Array(base64String) {
   const binaryString = atob(base64String);
@@ -110,6 +121,7 @@ function dateToString(date, type) {
   }
 }
 var StringWritableStream = class extends WritableStream {
+  result = "";
   constructor() {
     const decoder = new TextDecoder();
     super({
@@ -120,7 +132,6 @@ var StringWritableStream = class extends WritableStream {
         this.result += decoder.decode();
       }
     });
-    this.result = "";
   }
   /**
    * Returns the collected string result.
@@ -181,23 +192,34 @@ function convertToString(value, type) {
       return dateToString(value, type);
     case "BLOB":
       return uint8ArrayToBase64(value);
+    case "STRING":
+      return String(value);
     default:
       return String(value);
   }
 }
+var entities = makeParseEntities();
+function _unescapeXml(str) {
+  if (!str) return str;
+  const regex = new RegExp(entities.map((e) => e.entity).join("|"), "g");
+  return str.replace(regex, (match) => {
+    const entity = entities.find((e) => e.entity === match);
+    return entity ? entity.value : match;
+  });
+}
 
 // src/xapi-data.ts
 var XapiRoot = class {
+  /** An array of datasets within the X-API root. */
+  datasets = [];
+  /** Parameters associated with the X-API root. */
+  parameters = { params: [] };
   /**
    * Creates an instance of XapiRoot.
    * @param datasets - Initial array of datasets.
    * @param parameters - Initial parameters.
    */
   constructor(datasets = [], parameters = { params: [] }) {
-    /** An array of datasets within the X-API root. */
-    this.datasets = [];
-    /** Parameters associated with the X-API root. */
-    this.parameters = { params: [] };
     this.datasets = datasets;
     this.parameters = parameters;
   }
@@ -285,6 +307,13 @@ var XapiRoot = class {
   }
 };
 var Dataset = class {
+  /** The ID of the dataset. */
+  id;
+  constColumns = [];
+  columns = [];
+  /** An array of rows in the dataset. */
+  rows = [];
+  _columnIndexMap = /* @__PURE__ */ new Map();
   /**
    * Creates an instance of Dataset.
    * @param id - The ID of the dataset.
@@ -293,11 +322,6 @@ var Dataset = class {
    * @param rows - Initial array of rows.
    */
   constructor(id, constColumns = [], columns = [], rows = []) {
-    this.constColumns = [];
-    this.columns = [];
-    /** An array of rows in the dataset. */
-    this.rows = [];
-    this._columnIndexMap = /* @__PURE__ */ new Map();
     this.id = id;
     this.constColumns = constColumns;
     this.columns = columns;
@@ -478,127 +502,105 @@ function initXapi(options) {
     ...options
   };
 }
-async function parse(reader) {
-  let _stream;
-  if (typeof reader === "string") {
-    _stream = new ReadableStream({
-      start(controller) {
-        controller.enqueue(new TextEncoder().encode(reader));
-        controller.close();
-      }
-    });
-  } else {
-    _stream = reader;
-  }
-  const xmlParser = new StaxXmlParser(_stream, {
-    addEntities: makeParseEntities(),
-    encoding: "UTF-8"
-  });
+function parse2(xml) {
+  const parsedXml = txml.parse(xml);
   const xapiRoot = new XapiRoot();
-  for await (const event of xmlParser) {
-    if (event.type === XmlEventType.START_ELEMENT) {
-      const startEvent = event;
-      switch (startEvent.localName) {
-        case "Parameter":
-          let paramValue = void 0;
-          const charEvent = (await xmlParser.next()).value;
-          if (charEvent.type === XmlEventType.CHARACTERS) {
-            paramValue = charEvent.value;
-          }
-          xapiRoot.addParameter({
-            id: startEvent.attributes["id"],
-            type: startEvent.attributes["type"] || "STRING",
-            value: _options.parseToTypes ? convertToColumnType(paramValue, startEvent.attributes["type"] || "STRING") : paramValue
-          });
-          break;
-        case "Dataset":
-          xapiRoot.addDataset(await parseDataset(startEvent, xmlParser));
-          break;
+  const rootElement = parsedXml.find((node) => {
+    const rootNode = node;
+    return rootNode.tagName === "Root";
+  });
+  if (rootElement === void 0) return xapiRoot;
+  const parametersElement = rootElement.children?.find((node) => node.tagName === "Parameters");
+  parseParameters(parametersElement, xapiRoot);
+  const datasetsElements = rootElement.children?.filter((node) => node.tagName === "Dataset");
+  if (datasetsElements && datasetsElements?.length && datasetsElements.length > 0) {
+    for (const datasetsElement of datasetsElements) {
+      if (!datasetsElement.attributes || !datasetsElement.attributes.id) {
+        throw new InvalidXmlError("Dataset element must have an 'id' attribute");
       }
+      const datasetId = datasetsElement.attributes?.id;
+      const dataset = new Dataset(datasetId);
+      xapiRoot.addDataset(dataset);
+      const columnInfoElement = datasetsElement.children?.find((node) => node.tagName === "ColumnInfo");
+      parseColumnInfo(columnInfoElement, dataset);
+      const rowsElement = datasetsElement.children?.find((node) => node.tagName === "Rows");
+      parseRows(rowsElement, dataset);
     }
   }
   return xapiRoot;
 }
-async function parseDataset(initEvent, xmlParser) {
-  const dataset = new Dataset(initEvent.attributes["id"]);
-  let currentRowIndex = -1;
-  for await (const event of xmlParser) {
-    if (event.type === XmlEventType.END_ELEMENT && event.localName === "Dataset") {
-      break;
-    } else if (event.type === XmlEventType.START_ELEMENT) {
-      const startEvent = event;
-      switch (startEvent.localName) {
-        case "ConstColumn":
-          dataset.addConstColumn({
-            id: startEvent.attributes["id"],
-            size: parseInt(startEvent.attributes["size"] || "0", 10),
-            type: startEvent.attributes["type"] || "STRING",
-            value: startEvent.attributes["value"] || void 0
-          });
-          break;
-        case "Column":
-          dataset.addColumn({
-            id: startEvent.attributes["id"],
-            size: parseInt(startEvent.attributes["size"] || "0", 10),
-            type: startEvent.attributes["type"] || "STRING"
+function parseValue(value, type = "STRING") {
+  value = _unescapeXml(value);
+  return _options.parseToTypes ? convertToColumnType(value, type) : value;
+}
+function parseColumnInfo(columnInfoElement, dataset) {
+  if (!columnInfoElement) throw new InvalidXmlError("ColumnInfo element is missing in the dataset");
+  columnInfoElement.children?.forEach((colInfo) => {
+    if (colInfo.tagName === "ConstColumn") {
+      dataset.addConstColumn({
+        id: colInfo.attributes?.id,
+        size: parseInt(colInfo.attributes?.size || "0", 10),
+        type: colInfo.attributes?.type || "STRING",
+        value: parseValue(colInfo.attributes?.value, colInfo.attributes?.type)
+      });
+    } else if (colInfo.tagName === "Column") {
+      dataset.addColumn({
+        id: colInfo.attributes?.id,
+        size: parseInt(colInfo.attributes?.size || "0", 10),
+        type: colInfo.attributes?.type || "STRING"
+      });
+    }
+  });
+}
+function parseRows(rowsElement, dataset) {
+  rowsElement?.children?.forEach((r) => {
+    if (r.tagName === "Row") {
+      const rowIndex = dataset.newRow();
+      dataset.rows[rowIndex].type = r.attributes?.type || void 0;
+      r.children?.forEach((col) => {
+        if (col.tagName === "Col") {
+          const colId = col.attributes?.id;
+          const value = col.children?.[0];
+          const columnInfo = dataset.getColumnInfo(colId);
+          if (!columnInfo) throw new InvalidXmlError(`Column with id ${colId} not found in dataset ${dataset.id}`);
+          const castedValue = parseValue(value, columnInfo.type);
+          dataset.rows[rowIndex].cols.push({ id: colId, value: castedValue });
+        } else if (col.tagName === "OrgRow") {
+          dataset.rows[rowIndex].orgRow = [];
+          col.children?.forEach((orgCol) => {
+            if (orgCol.tagName === "Col") {
+              const colId = orgCol.attributes?.id;
+              const value = orgCol.children?.[0];
+              const columnInfo = dataset.getColumnInfo(colId);
+              const castedValue = parseValue(value, columnInfo.type);
+              if (dataset && dataset.rows && dataset.rows[rowIndex] && dataset.rows[rowIndex].orgRow) {
+                dataset.rows[rowIndex].orgRow.push({ id: colId, value: castedValue });
+              }
+            }
           });
-          break;
-        case "Row":
-          currentRowIndex = dataset.newRow();
-          dataset.rows[currentRowIndex].type = startEvent.attributes["type"] || void 0;
-          break;
-        case "Col": {
-          await parseCol(xmlParser, startEvent, dataset, currentRowIndex, false);
-          break;
         }
-        case "OrgRow":
-          if (currentRowIndex < 0) {
-            throw new Error("Row must be defined before OrgRow");
-          }
-          dataset.rows[currentRowIndex].orgRow = [];
-          for await (const orgRowEvent of xmlParser) {
-            if (orgRowEvent.type === XmlEventType.END_ELEMENT && orgRowEvent.localName === "OrgRow") {
-              break;
-            }
-            if (orgRowEvent.type === XmlEventType.START_ELEMENT && orgRowEvent.localName === "Col") {
-              const orgColEvent = orgRowEvent;
-              await parseCol(xmlParser, orgColEvent, dataset, currentRowIndex, true);
-            }
-          }
-      }
+      });
+    } else if (r.tagName === "Col") {
+      throw new InvalidXmlError("Row must be defined before Col");
+    } else if (r.tagName === "OrgRow") {
+      throw new InvalidXmlError("Row must be defined before OrgRow");
     }
-  }
-  return dataset;
+  });
 }
-async function parseCol(xmlParser, startEvent, dataset, currentRowIndex, isOrgRow) {
-  if (currentRowIndex < 0) {
-    throw new Error("Row must be defined before Col");
-  }
-  const colId = startEvent.attributes["id"];
-  const colIndex = dataset.getColumnIndex(colId);
-  if (colIndex === void 0 || colIndex < 0) {
-    throw new Error(`Column with id ${colId} not found in dataset ${dataset.id}`);
-  }
-  const colCharEvent = (await xmlParser.next()).value;
-  let value;
-  if (colCharEvent.type === XmlEventType.CDATA) {
-    value = colCharEvent.value;
-  } else if (colCharEvent.type === XmlEventType.CHARACTERS) {
-    value = colCharEvent.value;
-  }
-  let castedValue = value;
-  if (_options.parseToTypes) {
-    const columnInfo = dataset.getColumnInfo(colId);
-    if (!columnInfo || columnType.includes(columnInfo.type) === false) {
-      throw new Error(`Column type for ${colId} not found in dataset ${dataset.id}`);
+function parseParameters(parametersElement, xapiRoot) {
+  if (!parametersElement) return;
+  parametersElement.children?.forEach((p) => {
+    if (p.tagName === "Parameter") {
+      const id = p.attributes?.id;
+      const type = p.attributes?.type || "STRING";
+      const value = p.children?.[0];
+      xapiRoot.addParameter({
+        id,
+        type,
+        value: parseValue(value, type)
+      });
     }
-    castedValue = convertToColumnType(value, columnInfo.type);
-  }
-  if (!isOrgRow) {
-    dataset.rows[currentRowIndex].cols.push({ id: colId, value: castedValue });
-  } else {
-    dataset.rows[currentRowIndex].orgRow.push({ id: colId, value: castedValue });
-  }
+  });
 }
 async function writeString(root) {
   const stringStream = new StringWritableStream();
@@ -718,10 +720,13 @@ async function writeColumn(writer, dataset, col) {
 export {
   ColumnTypeError,
   Dataset,
+  InvalidXmlError,
   NexaVersion,
   StringWritableStream,
   XapiRoot,
   XplatformVersion,
+  _unescapeXml,
+  arrayBufferToString,
   base64ToUint8Array,
   columnType,
   convertToColumnType,
@@ -730,7 +735,7 @@ export {
   initXapi,
   makeParseEntities,
   makeWriterEntities,
-  parse,
+  parse2 as parse,
   rowType,
   stringToDate,
   stringToReadableStream,