@xapi-js/core 1.0.0

package/dist/index.cjs

@@ -0,0 +1,787 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ColumnTypeError: () => ColumnTypeError,
+  Dataset: () => Dataset,
+  NexaVersion: () => NexaVersion,
+  StringWritableStream: () => StringWritableStream,
+  XapiRoot: () => XapiRoot,
+  XplatformVersion: () => XplatformVersion,
+  base64ToUint8Array: () => base64ToUint8Array,
+  columnType: () => columnType,
+  convertToColumnType: () => convertToColumnType,
+  convertToString: () => convertToString,
+  dateToString: () => dateToString,
+  initXapi: () => initXapi,
+  makeParseEntities: () => makeParseEntities,
+  makeWriterEntities: () => makeWriterEntities,
+  parse: () => parse,
+  rowType: () => rowType,
+  stringToDate: () => stringToDate,
+  stringToReadableStream: () => stringToReadableStream,
+  uint8ArrayToBase64: () => uint8ArrayToBase64,
+  write: () => write,
+  writeString: () => writeString
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/handler.ts
+var import_stax_xml = require("stax-xml");
+
+// src/types.ts
+var rowType = ["insert", "update", "delete"];
+var columnType = ["STRING", "INT", "FLOAT", "DECIMAL", "BIGDECIMAL", "DATE", "DATETIME", "TIME", "BLOB"];
+var XplatformVersion = {
+  xmlns: "http://www.tobesoft.com/platform/Dataset",
+  version: "4000"
+};
+var NexaVersion = {
+  xmlns: "http://www.nexacroplatform.com/platform/dataset",
+  version: "4000"
+};
+var ColumnTypeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ColumnTypeError";
+  }
+};
+
+// src/utils.ts
+function makeParseEntities() {
+  const entities = [];
+  for (let i = 1; i <= 32; i++) {
+    entities.push({ entity: `&#${i};`, value: String.fromCharCode(i) });
+  }
+  return entities;
+}
+function makeWriterEntities() {
+  const entities = [];
+  for (let i = 1; i <= 32; i++) {
+    entities.push({ entity: `&#${i};`, value: String.fromCharCode(i) });
+  }
+  return entities;
+}
+function base64ToUint8Array(base64String) {
+  const binaryString = atob(base64String);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}
+function uint8ArrayToBase64(uint8Array) {
+  let binaryString = "";
+  for (let i = 0; i < uint8Array.length; i++) {
+    binaryString += String.fromCharCode(uint8Array[i]);
+  }
+  return btoa(binaryString);
+}
+function stringToDate(value) {
+  if (!value) return void 0;
+  let year;
+  let month;
+  let day;
+  let hours = 0;
+  let minutes = 0;
+  let seconds = 0;
+  let milliseconds = 0;
+  if (value.length < 6 || value.length > 16) {
+    return void 0;
+  }
+  if (value.length >= 8) {
+    year = parseInt(value.substring(0, 4), 10);
+    month = parseInt(value.substring(4, 6), 10) - 1;
+    day = parseInt(value.substring(6, 8), 10);
+  } else {
+    year = 1970;
+    month = 0;
+    day = 1;
+  }
+  if (value.length === 6) {
+    hours = parseInt(value.substring(0, 2), 10);
+    minutes = parseInt(value.substring(2, 4), 10);
+    seconds = parseInt(value.substring(4, 6), 10);
+  } else if (value.length >= 10) {
+    hours = parseInt(value.substring(8, 10), 10);
+    minutes = parseInt(value.substring(10, 12), 10);
+    seconds = parseInt(value.substring(12, 14), 10);
+  }
+  if (value.length === 16) {
+    milliseconds = parseInt(value.substring(14, 16), 10);
+  }
+  if (year < 1970 || year > 9999 || month < 0 || month > 11 || day < 1 || day > 31 || hours < 0 || hours > 23 || minutes < 0 || minutes > 59 || seconds < 0 || seconds > 59 || milliseconds < 0 || milliseconds > 999) {
+    return void 0;
+  }
+  const date = new Date(year, month, day, hours, minutes, seconds, milliseconds);
+  if (isNaN(date.getTime())) {
+    return void 0;
+  }
+  return date;
+}
+function dateToString(date, type) {
+  const year = date.getFullYear().toString().padStart(4, "0");
+  const month = (date.getMonth() + 1).toString().padStart(2, "0");
+  const day = date.getDate().toString().padStart(2, "0");
+  const hours = date.getHours().toString().padStart(2, "0");
+  const minutes = date.getMinutes().toString().padStart(2, "0");
+  const seconds = date.getSeconds().toString().padStart(2, "0");
+  switch (type) {
+    case "DATE":
+      return `${year}${month}${day}`;
+    case "DATETIME":
+      return `${year}${month}${day}${hours}${minutes}${seconds}`;
+    case "TIME":
+      return `${hours}${minutes}${seconds}`;
+    default:
+      return "";
+  }
+}
+var StringWritableStream = class extends WritableStream {
+  constructor() {
+    const decoder = new TextDecoder();
+    super({
+      write: (chunk) => {
+        this.result += decoder.decode(chunk, { stream: true });
+      },
+      close: () => {
+        this.result += decoder.decode();
+      }
+    });
+    this.result = "";
+  }
+  /**
+   * Returns the collected string result.
+   * @returns The concatenated string from all written chunks.
+   */
+  getResult() {
+    return this.result;
+  }
+};
+function stringToReadableStream(str) {
+  const encoder = new TextEncoder();
+  const bytes = encoder.encode(str);
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(bytes);
+      controller.close();
+    }
+  });
+}
+function convertToColumnType(value, type) {
+  switch (type) {
+    case "INT":
+    case "BIGDECIMAL":
+      const intValue = parseInt(value, 10);
+      return isNaN(intValue) ? value : intValue;
+    case "FLOAT":
+      const floatValue = parseFloat(value);
+      return isNaN(floatValue) ? value : floatValue;
+    case "DECIMAL":
+      const decimalValue = parseFloat(value);
+      return isNaN(decimalValue) ? value : decimalValue;
+    case "DATE":
+    case "DATETIME":
+    case "TIME":
+      return stringToDate(value) || value;
+    case "BLOB":
+      try {
+        return base64ToUint8Array(value);
+      } catch {
+        return value;
+      }
+    case "STRING":
+      return value;
+    default:
+      throw new ColumnTypeError(`Unsupported column type: ${type}`);
+  }
+}
+function convertToString(value, type) {
+  switch (type) {
+    case "INT":
+    case "BIGDECIMAL":
+    case "FLOAT":
+    case "DECIMAL":
+      return String(value);
+    case "DATE":
+    case "DATETIME":
+    case "TIME":
+      return dateToString(value, type);
+    case "BLOB":
+      return uint8ArrayToBase64(value);
+    default:
+      return String(value);
+  }
+}
+
+// src/xapi-data.ts
+var XapiRoot = class {
+  /**
+   * 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;
+  }
+  /**
+   * Adds a dataset to the X-API root.
+   * @param dataset - The dataset to add.
+   */
+  addDataset(dataset) {
+    this.datasets.push(dataset);
+  }
+  /**
+   * Retrieves a dataset by its ID.
+   * @param id - The ID of the dataset to retrieve.
+   * @returns The Dataset object, or undefined if not found.
+   */
+  getDataset(id) {
+    return this.datasets.find((dataset) => dataset.id === id);
+  }
+  /**
+   * Adds a parameter to the X-API root.
+   * @param parameter - The parameter to add.
+   */
+  addParameter(parameter) {
+    this.parameters.params.push(parameter);
+  }
+  /**
+   * Retrieves a parameter by its ID.
+   * @param id - The ID of the parameter to retrieve.
+   * @returns The Parameter object, or undefined if not found.
+   */
+  getParameter(id) {
+    return this.parameters.params.find((param) => param.id === id);
+  }
+  /**
+   * Sets all parameters for the X-API root.
+   * @param parameters - The XapiParameters object to set.
+   */
+  setParameters(parameters) {
+    this.parameters = parameters;
+  }
+  /**
+   * Sets the value of a specific parameter, or adds it if it doesn't exist.
+   * @param id - The ID of the parameter.
+   * @param value - The value to set for the parameter.
+   */
+  setParameter(id, value) {
+    const param = this.parameters.params.find((p) => p.id === id);
+    if (param) {
+      param.value = value;
+    } else {
+      this.addParameter({ id, value });
+    }
+  }
+  /**
+   * Returns the number of parameters.
+   * @returns The count of parameters.
+   */
+  parameterSize() {
+    return this.parameters.params.length;
+  }
+  /**
+   * Returns the number of datasets.
+   * @returns The count of datasets.
+   */
+  datasetSize() {
+    return this.datasets.length;
+  }
+  /**
+   * Iterates over the parameters.
+   * @returns An IterableIterator for parameters.
+   */
+  *iterParameters() {
+    for (const param of this.parameters.params) {
+      yield param;
+    }
+  }
+  /**
+   * Iterates over the datasets.
+   * @returns An IterableIterator for datasets.
+   */
+  *iterDatasets() {
+    for (const dataset of this.datasets) {
+      yield dataset;
+    }
+  }
+};
+var Dataset = class {
+  /**
+   * Creates an instance of Dataset.
+   * @param id - The ID of the dataset.
+   * @param constColumns - Initial array of constant columns.
+   * @param columns - Initial array of columns.
+   * @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;
+    this.rows = rows;
+  }
+  /**
+   * Adds a column definition to the dataset.
+   * @param column - The column definition to add.
+   */
+  addColumn(column) {
+    this.columns.push(column);
+    this._columnIndexMap.set(column.id, this.columns.length - 1);
+  }
+  /**
+   * Adds a constant column definition to the dataset.
+   * @param column - The constant column definition to add.
+   */
+  addConstColumn(column) {
+    this.constColumns.push(column);
+  }
+  /**
+   * Creates a new empty row and adds it to the dataset.
+   * @returns The index of the newly created row.
+   */
+  newRow() {
+    this.rows.push({ cols: [] });
+    return this.rows.length - 1;
+  }
+  /**
+   * Adds an existing row to the dataset.
+   * @param row - The row to add.
+   */
+  addRow(row) {
+    this.rows.push(row);
+  }
+  /**
+   * Retrieves the index of a column by its ID.
+   * @param columnId - The ID of the column.
+   * @returns The index of the column, or undefined if not found.
+   */
+  getColumnIndex(columnId) {
+    return this._columnIndexMap.get(columnId);
+  }
+  /**
+   * Retrieves the column definition by its ID.
+   * @param columnId - The ID of the column.
+   * @returns The Column object, or undefined if not found.
+   */
+  getColumnInfo(columnId) {
+    const colIndex = this.getColumnIndex(columnId);
+    if (colIndex !== void 0) {
+      return this.columns[colIndex];
+    }
+    return void 0;
+  }
+  /**
+   * Retrieves the constant column definition by its ID.
+   * @param columnId - The ID of the constant column.
+   * @returns The ConstColumn object, or undefined if not found.
+   */
+  getConstColumnInfo(columnId) {
+    return this.constColumns.find((col) => col.id === columnId);
+  }
+  /**
+   * Retrieves the value of a column in a specific row.
+   * @param rowIdx - The index of the row.
+   * @param columnId - The ID of the column.
+   * @returns The value of the column, or undefined if the row or column is not found.
+   * @throws {Error} if the column ID is not found in the dataset.
+   */
+  getColumn(rowIdx, columnId) {
+    if (rowIdx < this.rows.length) {
+      const colIndex = this.getColumnIndex(columnId);
+      if (colIndex === void 0) {
+        throw new Error(`Column with id ${columnId} not found in dataset ${this.id}`);
+      }
+      const col = this.rows[rowIdx].cols[colIndex];
+      return col?.value;
+    }
+    return void 0;
+  }
+  /**
+   * Retrieves the original value of a column in a specific row (for OrgRow).
+   * @param rowIdx - The index of the row.
+   * @param columnId - The ID of the column.
+   * @returns The original value of the column, or undefined if the row or column is not found.
+   * @throws {Error} if the column ID is not found in the dataset.
+   */
+  getOrgColumn(rowIdx, columnId) {
+    if (rowIdx < this.rows.length) {
+      const colIndex = this.getColumnIndex(columnId);
+      if (colIndex === void 0) {
+        throw new Error(`Column with id ${columnId} not found in dataset ${this.id}`);
+      }
+      const col = this.rows[rowIdx].orgRow?.[colIndex];
+      return col?.value;
+    }
+    return void 0;
+  }
+  /**
+   * Sets the value of a column in a specific row.
+   * @param rowIdx - The index of the row.
+   * @param columnId - The ID of the column.
+   * @param value - The value to set.
+   * @throws {Error} if the row index is out of bounds or the column ID is not found.
+   */
+  setColumn(rowIdx, columnId, value) {
+    if (rowIdx < this.rows.length) {
+      const colIndex = this.getColumnIndex(columnId);
+      if (colIndex === void 0) {
+        throw new Error(`Column with id ${columnId} not found in dataset ${this.id}`);
+      }
+      this.rows[rowIdx].cols[colIndex] = { id: columnId, value };
+    } else {
+      throw new Error(`Row index ${rowIdx} out of bounds in dataset ${this.id}`);
+    }
+  }
+  /**
+   * Iterates over the constant column definitions.
+   * @returns An IterableIterator for constant columns.
+   */
+  *iterConstColumns() {
+    for (const column of this.constColumns) {
+      yield column;
+    }
+  }
+  /**
+   * Iterates over the column definitions.
+   * @returns An IterableIterator for columns.
+   */
+  *iterColumns() {
+    for (const column of this.columns) {
+      yield column;
+    }
+  }
+  /**
+   * Iterates over the rows in the dataset.
+   * @returns An IterableIterator for rows.
+   */
+  *iterRows() {
+    for (const row of this.rows) {
+      yield row;
+    }
+  }
+  /**
+   * Returns the number of column definitions.
+   * @returns The count of columns.
+   */
+  columnSize() {
+    return this.columns.length;
+  }
+  /**
+   * Returns the number of constant column definitions.
+   * @returns The count of constant columns.
+   */
+  constColumnSize() {
+    return this.constColumns.length;
+  }
+  /**
+   * Returns the number of rows in the dataset.
+   * @returns The count of rows.
+   */
+  rowSize() {
+    return this.rows.length;
+  }
+};
+
+// src/handler.ts
+var defaultOptions = {
+  xapiVersion: NexaVersion,
+  parseToTypes: true
+};
+var _options = {
+  ...defaultOptions
+};
+function initXapi(options) {
+  _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 import_stax_xml.StaxXmlParser(_stream, {
+    addEntities: makeParseEntities(),
+    encoding: "UTF-8"
+  });
+  const xapiRoot = new XapiRoot();
+  for await (const event of xmlParser) {
+    if (event.type === import_stax_xml.XmlEventType.START_ELEMENT) {
+      const startEvent = event;
+      switch (startEvent.localName) {
+        case "Parameter":
+          let paramValue = void 0;
+          const charEvent = (await xmlParser.next()).value;
+          if (charEvent.type === import_stax_xml.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;
+      }
+    }
+  }
+  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 === import_stax_xml.XmlEventType.END_ELEMENT && event.localName === "Dataset") {
+      break;
+    } else if (event.type === import_stax_xml.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"
+          });
+          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 === import_stax_xml.XmlEventType.END_ELEMENT && orgRowEvent.localName === "OrgRow") {
+              break;
+            }
+            if (orgRowEvent.type === import_stax_xml.XmlEventType.START_ELEMENT && orgRowEvent.localName === "Col") {
+              const orgColEvent = orgRowEvent;
+              await parseCol(xmlParser, orgColEvent, dataset, currentRowIndex, true);
+            }
+          }
+      }
+    }
+  }
+  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 === import_stax_xml.XmlEventType.CDATA) {
+    value = colCharEvent.value;
+  } else if (colCharEvent.type === import_stax_xml.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}`);
+    }
+    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();
+  await write(stringStream, root);
+  return stringStream.getResult();
+}
+async function write(stream, root) {
+  const writer = new import_stax_xml.StaxXmlWriter(stream, {
+    addEntities: makeWriterEntities(),
+    encoding: "UTF-8",
+    indentString: "  ",
+    prettyPrint: true
+  });
+  await writer.writeStartDocument("1.0", "UTF-8");
+  await writer.writeStartElement("Root", {
+    // Root
+    attributes: {
+      xmlns: _options.xapiVersion?.xmlns || NexaVersion.xmlns,
+      version: _options.xapiVersion?.version || NexaVersion.version
+    }
+  });
+  if (root.parameterSize() > 0) {
+    await writeParameters(writer, root.iterParameters());
+  }
+  if (root.datasetSize() > 0) {
+    await writer.writeStartElement("Datasets");
+    for (const dataset of root.iterDatasets()) {
+      await writeDataset(writer, dataset);
+    }
+    await writer.writeEndElement();
+  }
+  await writer.writeEndElement();
+}
+async function writeParameters(writer, iterator) {
+  if (iterator) {
+    await writer.writeStartElement("Parameters");
+    for (const parameter of iterator) {
+      await writer.writeStartElement("Parameter", { attributes: { id: parameter.id } });
+      if (parameter.type !== void 0) {
+        await writer.writeAttribute("type", parameter.type);
+      }
+      if (parameter.value !== void 0) {
+        if (typeof parameter.value === "string") {
+          await writer.writeAttribute("value", parameter.value);
+        } else if (parameter.value instanceof Date) {
+          await writer.writeAttribute("value", dateToString(parameter.value, parameter.type));
+        } else if (parameter.value instanceof Uint8Array) {
+          await writer.writeAttribute("value", uint8ArrayToBase64(parameter.value));
+        } else {
+          await writer.writeAttribute("value", String(parameter.value));
+        }
+      }
+      await writer.writeEndElement();
+    }
+    await writer.writeEndElement();
+  }
+}
+async function writeDataset(writer, dataset) {
+  await writer.writeStartElement("Dataset", { attributes: { id: dataset.id } });
+  if (dataset.constColumnSize() > 0 || dataset.columnSize() > 0) {
+    await writer.writeStartElement("ColumnInfo");
+    for (const constCol of dataset.iterConstColumns()) {
+      await writer.writeStartElement("ConstColumn", {
+        attributes: {
+          id: constCol.id,
+          size: String(constCol.size),
+          type: constCol.type,
+          value: constCol.value !== void 0 ? String(constCol.value) : ""
+        },
+        selfClosing: true
+      });
+    }
+    for (const col of dataset.iterColumns()) {
+      await writer.writeStartElement("Column", {
+        attributes: {
+          id: col.id,
+          size: String(col.size),
+          type: col.type
+        },
+        selfClosing: true
+      });
+    }
+    await writer.writeEndElement();
+  }
+  await writer.writeStartElement("Rows");
+  for (const row of dataset.iterRows()) {
+    if (row.type) {
+      await writer.writeStartElement("Row", { attributes: { type: row.type } });
+    } else {
+      await writer.writeStartElement("Row");
+    }
+    for (const col of row.cols) {
+      await writeColumn(writer, dataset, col);
+    }
+    if (row.orgRow && row.orgRow.length > 0) {
+      await writer.writeStartElement("OrgRow");
+      for (const orgCol of row.orgRow) {
+        await writeColumn(writer, dataset, orgCol);
+      }
+      await writer.writeEndElement();
+    }
+    await writer.writeEndElement();
+  }
+  await writer.writeEndElement();
+  await writer.writeEndElement();
+}
+async function writeColumn(writer, dataset, col) {
+  if (col.value !== void 0 && col.value !== null) {
+    const colInfo = dataset.getColumnInfo(col.id);
+    await writer.writeStartElement("Col", { attributes: { id: col.id } });
+    await writer.writeCharacters(convertToString(col.value, colInfo.type));
+    await writer.writeEndElement();
+  } else {
+    await writer.writeStartElement("Col", { attributes: { id: col.id }, selfClosing: true });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ColumnTypeError,
+  Dataset,
+  NexaVersion,
+  StringWritableStream,
+  XapiRoot,
+  XplatformVersion,
+  base64ToUint8Array,
+  columnType,
+  convertToColumnType,
+  convertToString,
+  dateToString,
+  initXapi,
+  makeParseEntities,
+  makeWriterEntities,
+  parse,
+  rowType,
+  stringToDate,
+  stringToReadableStream,
+  uint8ArrayToBase64,
+  write,
+  writeString
+});