@cfworker/csv 1.12.2 → 1.12.5

package/dist/encode.d.ts

@@ -1 +1,9 @@
-export declare function encode(rows: any[]): ReadableStream;
+export interface EncodeOptions<T> {
+    columns?: Column<T, keyof T>[];
+}
+export interface Column<T, K extends keyof T> {
+    key: K;
+    label: string;
+    format: (value: T[K], row: T) => unknown;
+}
+export declare function encode<T>(rows: T[], { columns }?: EncodeOptions<T>): ReadableStream;

package/dist/encode.js

@@ -3,30 +3,35 @@ const quoteRegex = /"/g;
 const delimiter = ',';
 const rowDelimiter = '\r\n';
 const requiresQuoteRegex = /["\r\n,]/;
-export function encode(rows) {
+export function encode(rows, { columns } = {}) {
     const { readable, writable } = new TransformStream();
     (async () => {
         const writer = writable.getWriter();
-        await writeRows(writer, rows);
+        if (rows.length > 0) {
+            if (!columns) {
+                columns = Object.keys(rows[0]).map(key => ({
+                    key: key,
+                    label: key,
+                    format: (x) => x
+                }));
+            }
+            await writeRows(writer, rows, columns);
+        }
         await writer.close();
     })();
     return readable;
 }
-async function writeRows(writer, rows) {
+async function writeRows(writer, rows, columns) {
     const text = new TextEncoder();
     const utf8 = text.encode.bind(text);
     const write = writer.write.bind(writer);
-    let keys = undefined;
+    await write(utf8(columns.map(c => encodeValue(c.label)).join(delimiter)));
     for (const row of rows) {
-        if (keys === undefined) {
-            keys = Object.keys(row);
-            await write(utf8(keys.map(encodeValue).join(delimiter)));
-        }
         await write(utf8(rowDelimiter));
         let s = '';
         let first = true;
-        for (const key of keys) {
-            s += (first ? '' : ',') + encodeValue(row[key]);
+        for (const { key, format } of columns) {
+            s += (first ? '' : ',') + encodeValue(format(row[key], row));
             first = false;
         }
         await write(utf8(s));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfworker/csv",
-  "version": "1.12.2",
+  "version": "1.12.5",
   "description": "Streaming CSV encoding for Cloudflare Workers and service workers",
   "sideEffects": false,
   "main": "dist/index.js",
@@ -27,11 +27,11 @@
     "test": "cfworker test test/**/*.spec.ts"
   },
   "devDependencies": {
-    "@cfworker/dev": "^1.14.0",
-    "@types/chai": "^4.3.0",
-    "@types/mocha": "^9.1.0",
+    "@cfworker/dev": "^1.14.1",
+    "@types/chai": "^4.3.3",
+    "@types/mocha": "^9.1.1",
     "chai": "^4.3.6",
-    "mocha": "^9.2.1",
-    "typescript": "^4.5.5"
+    "mocha": "^10.0.0",
+    "typescript": "^4.7.4"
   }
 }

package/src/encode.ts

@@ -4,40 +4,69 @@ const delimiter = ',';
 const rowDelimiter = '\r\n';
 const requiresQuoteRegex = /["\r\n,]/;
 
-export function encode(rows: any[]): ReadableStream {
+export interface EncodeOptions<T> {
+  /**
+   * Properties to include
+   */
+  columns?: Column<T, keyof T>[];
+}
+
+export interface Column<T, K extends keyof T> {
+  key: K;
+  label: string;
+  format: (value: T[K], row: T) => unknown;
+}
+
+/**
+ * Encode an array of objects as a CSV
+ * @param rows An array of objects. Each item in the array represents a row.
+ * @param options
+ * @returns
+ */
+export function encode<T>(
+  rows: T[],
+  { columns }: EncodeOptions<T> = {}
+): ReadableStream {
   // Cloudflare Workers cannot construct a ReadableStream
   const { readable, writable } = new TransformStream();
-
   (async () => {
     const writer = writable.getWriter();
-    await writeRows(writer, rows);
+    if (rows.length > 0) {
+      if (!columns) {
+        columns = Object.keys(rows[0]).map(key => ({
+          key: key as keyof T,
+          label: key,
+          format: (x: any) => x
+        }));
+      }
+      await writeRows(writer, rows, columns);
+    }
     await writer.close();
   })();
 
   return readable;
 }
 
-async function writeRows(writer: WritableStreamDefaultWriter, rows: any[]) {
+async function writeRows<T>(
+  writer: WritableStreamDefaultWriter,
+  rows: T[],
+  columns: Column<T, keyof T>[]
+) {
   const text = new TextEncoder();
   const utf8 = text.encode.bind(text);
   const write = writer.write.bind(writer);
-  let keys: string[] | undefined = undefined;
+  // write header row
+  await write(utf8(columns.map(c => encodeValue(c.label)).join(delimiter)));
 
   for (const row of rows) {
-    // write header row
-    if (keys === undefined) {
-      keys = Object.keys(row);
-      await write(utf8(keys.map(encodeValue).join(delimiter)));
-    }
-
     // write row delimiter
     await write(utf8(rowDelimiter));
 
     // write data row
     let s = '';
     let first = true;
-    for (const key of keys) {
-      s += (first ? '' : ',') + encodeValue(row[key]);
+    for (const { key, format } of columns) {
+      s += (first ? '' : ',') + encodeValue(format(row[key], row));
       first = false;
     }
     await write(utf8(s));