@loaders.gl/csv 4.0.0-alpha.5 → 4.0.0-alpha.6

package/dist/dist.min.js

@@ -13,12 +13,12 @@
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
-  // ../schema/src/lib/batches/base-table-batch-aggregator.ts
-  var DEFAULT_ROW_COUNT, RowTableBatchAggregator;
+  // ../schema/src/lib/table/batches/base-table-batch-aggregator.ts
+  var DEFAULT_ROW_COUNT, BaseTableBatchAggregator;
   var init_base_table_batch_aggregator = __esm({
-    "../schema/src/lib/batches/base-table-batch-aggregator.ts"() {
+    "../schema/src/lib/table/batches/base-table-batch-aggregator.ts"() {
       DEFAULT_ROW_COUNT = 100;
-      RowTableBatchAggregator = class {
+      BaseTableBatchAggregator = class {
         constructor(schema, options) {
           this.length = 0;
           this.rows = null;
@@ -73,7 +73,7 @@
     }
   });
 
-  // ../schema/src/lib/utils/row-utils.ts
+  // ../schema/src/lib/table/simple-table/row-utils.ts
   function convertToObjectRow(arrayRow, headers) {
     if (!arrayRow) {
       throw new Error("null row");
@@ -101,17 +101,17 @@
     return arrayRow;
   }
   var init_row_utils = __esm({
-    "../schema/src/lib/utils/row-utils.ts"() {
+    "../schema/src/lib/table/simple-table/row-utils.ts"() {
     }
   });
 
-  // ../schema/src/lib/batches/row-table-batch-aggregator.ts
-  var DEFAULT_ROW_COUNT2, RowTableBatchAggregator2;
+  // ../schema/src/lib/table/batches/row-table-batch-aggregator.ts
+  var DEFAULT_ROW_COUNT2, RowTableBatchAggregator;
   var init_row_table_batch_aggregator = __esm({
-    "../schema/src/lib/batches/row-table-batch-aggregator.ts"() {
+    "../schema/src/lib/table/batches/row-table-batch-aggregator.ts"() {
       init_row_utils();
       DEFAULT_ROW_COUNT2 = 100;
-      RowTableBatchAggregator2 = class {
+      RowTableBatchAggregator = class {
         constructor(schema, options) {
           this.length = 0;
           this.objectRows = null;
@@ -183,10 +183,10 @@
     }
   });
 
-  // ../schema/src/lib/batches/columnar-table-batch-aggregator.ts
+  // ../schema/src/lib/table/batches/columnar-table-batch-aggregator.ts
   var DEFAULT_ROW_COUNT3, ColumnarTableBatchAggregator;
   var init_columnar_table_batch_aggregator = __esm({
-    "../schema/src/lib/batches/columnar-table-batch-aggregator.ts"() {
+    "../schema/src/lib/table/batches/columnar-table-batch-aggregator.ts"() {
       DEFAULT_ROW_COUNT3 = 100;
       ColumnarTableBatchAggregator = class {
         constructor(schema, options) {
@@ -264,10 +264,10 @@
     }
   });
 
-  // ../schema/src/lib/batches/table-batch-builder.ts
+  // ../schema/src/lib/table/batches/table-batch-builder.ts
   var DEFAULT_OPTIONS, ERR_MESSAGE, TableBatchBuilder;
   var init_table_batch_builder = __esm({
-    "../schema/src/lib/batches/table-batch-builder.ts"() {
+    "../schema/src/lib/table/batches/table-batch-builder.ts"() {
       init_base_table_batch_aggregator();
       init_row_table_batch_aggregator();
       init_columnar_table_batch_aggregator();
@@ -382,10 +382,10 @@
         _getTableBatchType() {
           switch (this.options.shape) {
             case "row-table":
-              return RowTableBatchAggregator;
+              return BaseTableBatchAggregator;
             case "array-row-table":
             case "object-row-table":
-              return RowTableBatchAggregator2;
+              return RowTableBatchAggregator;
             case "columnar-table":
               return ColumnarTableBatchAggregator;
             case "arrow-table":
@@ -401,6 +401,98 @@
     }
   });
 
+  // ../schema/src/lib/table/simple-table/table-accessors.ts
+  function getTableLength(table) {
+    switch (table.shape) {
+      case "array-row-table":
+      case "object-row-table":
+      case "geojson-row-table":
+        return table.data.length;
+      case "arrow-table":
+        return table.data.numRows;
+      case "columnar-table":
+        for (const column of Object.values(table.data)) {
+          return column.length || 0;
+        }
+        return 0;
+      default:
+        throw new Error("table");
+    }
+  }
+  function getTableNumCols(table) {
+    if (table.schema) {
+      return table.schema.fields.length;
+    }
+    if (getTableLength(table) === 0) {
+      throw new Error("empty table");
+    }
+    switch (table.shape) {
+      case "array-row-table":
+        return table.data[0].length;
+      case "object-row-table":
+      case "geojson-row-table":
+        return Object.keys(table.data[0]).length;
+      case "columnar-table":
+        return Object.keys(table.data).length;
+      case "arrow-table":
+        return table.data.numCols;
+      default:
+        throw new Error("table");
+    }
+  }
+  function getTableRowAsArray(table, rowIndex, target, copy2) {
+    switch (table.shape) {
+      case "array-row-table":
+        return copy2 ? Array.from(table.data[rowIndex]) : table.data[rowIndex];
+      case "object-row-table":
+      case "geojson-row-table":
+        if (table.schema) {
+          const arrayRow2 = target || [];
+          for (let i = 0; i < table.schema.fields.length; i++) {
+            arrayRow2[i] = table.data[rowIndex][table.schema.fields[i].name];
+          }
+          return arrayRow2;
+        }
+        return Object.values(table.data[rowIndex]);
+      case "columnar-table":
+        if (table.schema) {
+          const arrayRow2 = target || [];
+          for (let i = 0; i < table.schema.fields.length; i++) {
+            arrayRow2[i] = table.data[table.schema.fields[i].name][rowIndex];
+          }
+          return arrayRow2;
+        } else {
+          const arrayRow2 = target || [];
+          let i = 0;
+          for (const column of Object.values(table.data)) {
+            arrayRow2[i] = column[rowIndex];
+            i++;
+          }
+          return arrayRow2;
+        }
+      case "arrow-table":
+        const arrayRow = target || [];
+        const row = table.data.get(rowIndex);
+        const schema = table.data.schema;
+        for (let i = 0; i < schema.fields.length; i++) {
+          arrayRow[i] = row?.[schema.fields[i].name];
+        }
+        return arrayRow;
+      default:
+        throw new Error("shape");
+    }
+  }
+  function* makeArrayRowIterator(table, target = []) {
+    const length = getTableLength(table);
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+      yield getTableRowAsArray(table, rowIndex, target);
+    }
+  }
+  var init_table_accessors = __esm({
+    "../schema/src/lib/table/simple-table/table-accessors.ts"() {
+    }
+  });
+
   // ../schema/src/lib/utils/async-queue.ts
   var ArrayQueue, AsyncQueue;
   var init_async_queue = __esm({
@@ -472,6 +564,7 @@
   var init_src = __esm({
     "../schema/src/index.ts"() {
       init_table_batch_builder();
+      init_table_accessors();
       init_row_utils();
       init_async_queue();
     }
@@ -582,7 +675,7 @@
       return keys;
     }
     function serialize(fields, data, skipEmptyLines) {
-      var csv = "";
+      var csv2 = "";
       if (typeof fields === "string")
         fields = JSON.parse(fields);
       if (typeof data === "string")
@@ -592,11 +685,11 @@
       if (hasHeader && _writeHeader) {
         for (var i = 0; i < fields.length; i++) {
           if (i > 0)
-            csv += _delimiter;
-          csv += safe(fields[i], i);
+            csv2 += _delimiter;
+          csv2 += safe(fields[i], i);
         }
         if (data.length > 0)
-          csv += _newline;
+          csv2 += _newline;
       }
       for (var row = 0; row < data.length; row++) {
         var maxCol = hasHeader ? fields.length : data[row].length;
@@ -616,16 +709,16 @@
         if (!emptyLine) {
           for (var col = 0; col < maxCol; col++) {
             if (col > 0 && !nullLine)
-              csv += _delimiter;
+              csv2 += _delimiter;
             var colIdx = hasHeader && dataKeyedByField ? fields[col] : col;
-            csv += safe(data[row][colIdx], col);
+            csv2 += safe(data[row][colIdx], col);
           }
           if (row < data.length - 1 && (!skipEmptyLines || maxCol > 0 && !nullLine)) {
-            csv += _newline;
+            csv2 += _newline;
           }
         }
       }
-      return csv;
+      return csv2;
     }
     function safe(str, col) {
       if (typeof str === "undefined" || str === null)
@@ -1474,21 +1567,252 @@
     }
   });
 
+  // ../../node_modules/d3-dsv/src/dsv.js
+  function objectConverter(columns) {
+    return new Function("d", "return {" + columns.map(function(name, i) {
+      return JSON.stringify(name) + ": d[" + i + '] || ""';
+    }).join(",") + "}");
+  }
+  function customConverter(columns, f) {
+    var object = objectConverter(columns);
+    return function(row, i) {
+      return f(object(row), i, columns);
+    };
+  }
+  function inferColumns(rows) {
+    var columnSet = Object.create(null), columns = [];
+    rows.forEach(function(row) {
+      for (var column in row) {
+        if (!(column in columnSet)) {
+          columns.push(columnSet[column] = column);
+        }
+      }
+    });
+    return columns;
+  }
+  function pad(value, width) {
+    var s = value + "", length = s.length;
+    return length < width ? new Array(width - length + 1).join(0) + s : s;
+  }
+  function formatYear(year) {
+    return year < 0 ? "-" + pad(-year, 6) : year > 9999 ? "+" + pad(year, 6) : pad(year, 4);
+  }
+  function formatDate(date) {
+    var hours = date.getUTCHours(), minutes = date.getUTCMinutes(), seconds = date.getUTCSeconds(), milliseconds = date.getUTCMilliseconds();
+    return isNaN(date) ? "Invalid Date" : formatYear(date.getUTCFullYear(), 4) + "-" + pad(date.getUTCMonth() + 1, 2) + "-" + pad(date.getUTCDate(), 2) + (milliseconds ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + ":" + pad(seconds, 2) + "." + pad(milliseconds, 3) + "Z" : seconds ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + ":" + pad(seconds, 2) + "Z" : minutes || hours ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + "Z" : "");
+  }
+  function dsv_default(delimiter) {
+    var reFormat = new RegExp('["' + delimiter + "\n\r]"), DELIMITER = delimiter.charCodeAt(0);
+    function parse(text, f) {
+      var convert, columns, rows = parseRows(text, function(row, i) {
+        if (convert)
+          return convert(row, i - 1);
+        columns = row, convert = f ? customConverter(row, f) : objectConverter(row);
+      });
+      rows.columns = columns || [];
+      return rows;
+    }
+    function parseRows(text, f) {
+      var rows = [], N = text.length, I = 0, n = 0, t, eof = N <= 0, eol = false;
+      if (text.charCodeAt(N - 1) === NEWLINE)
+        --N;
+      if (text.charCodeAt(N - 1) === RETURN)
+        --N;
+      function token() {
+        if (eof)
+          return EOF;
+        if (eol)
+          return eol = false, EOL;
+        var i, j = I, c;
+        if (text.charCodeAt(j) === QUOTE) {
+          while (I++ < N && text.charCodeAt(I) !== QUOTE || text.charCodeAt(++I) === QUOTE)
+            ;
+          if ((i = I) >= N)
+            eof = true;
+          else if ((c = text.charCodeAt(I++)) === NEWLINE)
+            eol = true;
+          else if (c === RETURN) {
+            eol = true;
+            if (text.charCodeAt(I) === NEWLINE)
+              ++I;
+          }
+          return text.slice(j + 1, i - 1).replace(/""/g, '"');
+        }
+        while (I < N) {
+          if ((c = text.charCodeAt(i = I++)) === NEWLINE)
+            eol = true;
+          else if (c === RETURN) {
+            eol = true;
+            if (text.charCodeAt(I) === NEWLINE)
+              ++I;
+          } else if (c !== DELIMITER)
+            continue;
+          return text.slice(j, i);
+        }
+        return eof = true, text.slice(j, N);
+      }
+      while ((t = token()) !== EOF) {
+        var row = [];
+        while (t !== EOL && t !== EOF)
+          row.push(t), t = token();
+        if (f && (row = f(row, n++)) == null)
+          continue;
+        rows.push(row);
+      }
+      return rows;
+    }
+    function preformatBody(rows, columns) {
+      return rows.map(function(row) {
+        return columns.map(function(column) {
+          return formatValue(row[column]);
+        }).join(delimiter);
+      });
+    }
+    function format(rows, columns) {
+      if (columns == null)
+        columns = inferColumns(rows);
+      return [columns.map(formatValue).join(delimiter)].concat(preformatBody(rows, columns)).join("\n");
+    }
+    function formatBody(rows, columns) {
+      if (columns == null)
+        columns = inferColumns(rows);
+      return preformatBody(rows, columns).join("\n");
+    }
+    function formatRows(rows) {
+      return rows.map(formatRow).join("\n");
+    }
+    function formatRow(row) {
+      return row.map(formatValue).join(delimiter);
+    }
+    function formatValue(value) {
+      return value == null ? "" : value instanceof Date ? formatDate(value) : reFormat.test(value += "") ? '"' + value.replace(/"/g, '""') + '"' : value;
+    }
+    return {
+      parse,
+      parseRows,
+      format,
+      formatBody,
+      formatRows,
+      formatRow,
+      formatValue
+    };
+  }
+  var EOL, EOF, QUOTE, NEWLINE, RETURN;
+  var init_dsv = __esm({
+    "../../node_modules/d3-dsv/src/dsv.js"() {
+      EOL = {};
+      EOF = {};
+      QUOTE = 34;
+      NEWLINE = 10;
+      RETURN = 13;
+    }
+  });
+
+  // ../../node_modules/d3-dsv/src/csv.js
+  var csv, csvParse, csvParseRows, csvFormat, csvFormatBody, csvFormatRows, csvFormatRow, csvFormatValue;
+  var init_csv = __esm({
+    "../../node_modules/d3-dsv/src/csv.js"() {
+      init_dsv();
+      csv = dsv_default(",");
+      csvParse = csv.parse;
+      csvParseRows = csv.parseRows;
+      csvFormat = csv.format;
+      csvFormatBody = csv.formatBody;
+      csvFormatRows = csv.formatRows;
+      csvFormatRow = csv.formatRow;
+      csvFormatValue = csv.formatValue;
+    }
+  });
+
+  // ../../node_modules/d3-dsv/src/index.js
+  var init_src2 = __esm({
+    "../../node_modules/d3-dsv/src/index.js"() {
+      init_csv();
+    }
+  });
+
+  // src/lib/encoders/encode-csv.ts
+  function encodeTableAsCSV(table, options = { csv: { useDisplayNames: true } }) {
+    const useDisplayNames = options.useDisplayNames || options.csv?.useDisplayNames;
+    const fields = table.schema?.fields || [];
+    const columnNames = fields.map((f) => {
+      const displayName = f.metadata?.displayName;
+      return useDisplayNames && typeof displayName === "string" ? displayName : f.name;
+    });
+    const formattedData = [columnNames];
+    for (const row of makeArrayRowIterator(table)) {
+      const formattedRow = [];
+      for (let columnIndex = 0; columnIndex < getTableNumCols(table); ++columnIndex) {
+        const value = row[columnIndex];
+        formattedRow[columnIndex] = preformatFieldValue(value);
+      }
+      formattedData.push(formattedRow);
+    }
+    return csvFormatRows(formattedData);
+  }
+  var preformatFieldValue;
+  var init_encode_csv = __esm({
+    "src/lib/encoders/encode-csv.ts"() {
+      init_src();
+      init_src2();
+      preformatFieldValue = (value) => {
+        if (value === null || value === void 0) {
+          return null;
+        }
+        if (value instanceof Date) {
+          return value.toISOString();
+        }
+        if (typeof value === "object") {
+          return JSON.stringify(value);
+        }
+        return String(value);
+      };
+    }
+  });
+
+  // src/csv-writer.ts
+  var DEFAULT_WRITER_OPTIONS, CSVWriter;
+  var init_csv_writer = __esm({
+    "src/csv-writer.ts"() {
+      init_encode_csv();
+      DEFAULT_WRITER_OPTIONS = {
+        csv: {
+          useDisplayNames: false
+        },
+        useDisplayNames: false
+      };
+      CSVWriter = {
+        id: "csv",
+        version: "latest",
+        module: "csv",
+        name: "CSV",
+        extensions: ["csv"],
+        mimeTypes: ["text/csv"],
+        options: DEFAULT_WRITER_OPTIONS,
+        text: true,
+        encode: async (table, options) => new TextEncoder().encode(encodeTableAsCSV(table, options)).buffer,
+        encodeText: (table, options) => encodeTableAsCSV(table, options)
+      };
+    }
+  });
+
   // src/index.ts
   var src_exports = {};
   __export(src_exports, {
-    CSVLoader: () => CSVLoader
+    CSVLoader: () => CSVLoader,
+    CSVWriter: () => CSVWriter
   });
-  var init_src2 = __esm({
+  var init_src3 = __esm({
     "src/index.ts"() {
       init_csv_loader();
+      init_csv_writer();
     }
   });
 
   // src/bundle.ts
   var require_bundle = __commonJS({
     "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src2(), src_exports);
+      var moduleExports = (init_src3(), src_exports);
       globalThis.loaders = globalThis.loaders || {};
       module.exports = Object.assign(globalThis.loaders, moduleExports);
     }

package/dist/es5/bundle.js

@@ -0,0 +1,6 @@
+"use strict";
+
+var moduleExports = require('./index');
+globalThis.loaders = globalThis.loaders || {};
+module.exports = Object.assign(globalThis.loaders, moduleExports);
+//# sourceMappingURL=bundle.js.map

package/dist/es5/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.js","names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"sources":["../../src/bundle.ts"],"sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"mappings":";;AACA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAS,CAAC;AACxCC,UAAU,CAACC,OAAO,GAAGD,UAAU,CAACC,OAAO,IAAI,CAAC,CAAC;AAC7CC,MAAM,CAACC,OAAO,GAAGC,MAAM,CAACC,MAAM,CAACL,UAAU,CAACC,OAAO,EAAEH,aAAa,CAAC"}