web-csv-toolbox 0.13.1-next-afac98bd3a41b6e902268ac4ca6a99a8da883c81 → 0.14.0-next-fe8f8c27b5fcf2744b32ad7dca0a70ed7f47c915

package/dist/getOptionsFromRequest.js

@@ -0,0 +1,41 @@
+import { SUPPORTED_COMPRESSIONS } from './getOptionsFromResponse.constants.web.js';
+import { parseMime } from './utils/parseMime.js';
+
+function getOptionsFromRequest(request, options = {}) {
+  const { headers } = request;
+  const contentType = headers.get("content-type") ?? "text/csv";
+  const mime = parseMime(contentType);
+  if (mime.type !== "text/csv") {
+    throw new TypeError(`Invalid mime type: "${contentType}"`);
+  }
+  const contentEncoding = headers.get("content-encoding");
+  let decompression;
+  if (contentEncoding) {
+    const normalizedEncoding = contentEncoding.trim().toLowerCase();
+    if (normalizedEncoding.includes(",")) {
+      throw new TypeError(
+        `Multiple content-encodings are not supported: "${contentEncoding}"`
+      );
+    }
+    if (SUPPORTED_COMPRESSIONS.has(normalizedEncoding)) {
+      decompression = normalizedEncoding;
+    } else if (normalizedEncoding) {
+      if (options.allowExperimentalCompressions) {
+        decompression = normalizedEncoding;
+      } else {
+        throw new TypeError(
+          `Unsupported content-encoding: "${contentEncoding}". Supported formats: ${Array.from(SUPPORTED_COMPRESSIONS).join(", ")}. To use experimental formats, set allowExperimentalCompressions: true`
+        );
+      }
+    }
+  }
+  const charset = mime.parameters.charset ?? "utf-8";
+  return {
+    decompression,
+    charset,
+    ...options
+  };
+}
+
+export { getOptionsFromRequest };
+//# sourceMappingURL=getOptionsFromRequest.js.map

package/dist/getOptionsFromRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOptionsFromRequest.js","sources":["../src/getOptionsFromRequest.ts"],"sourcesContent":["import { SUPPORTED_COMPRESSIONS } from \"#getOptionsFromResponse.constants.js\";\nimport type { ParseBinaryOptions } from \"./common/types.ts\";\nimport type { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from \"./constants.ts\";\nimport { parseMime } from \"./utils/parseMime.ts\";\n\n/**\n * Extracts the options from the request object.\n *\n * @param request - The request object from which to extract the options.\n * @param options - The options to merge with the extracted options.\n * @returns The options extracted from the request.\n * @throws {TypeError} - The content type is not supported or the content-encoding is invalid.\n */\nexport function getOptionsFromRequest<\n  Header extends ReadonlyArray<string>,\n  Delimiter extends string = DEFAULT_DELIMITER,\n  Quotation extends string = '\"',\n>(\n  request: Request,\n  options: ParseBinaryOptions<\n    Header,\n    Delimiter,\n    Quotation\n  > = {} as ParseBinaryOptions<Header, Delimiter, Quotation>,\n): ParseBinaryOptions<Header, Delimiter, Quotation> {\n  const { headers } = request;\n  const contentType = headers.get(\"content-type\") ?? \"text/csv\";\n  const mime = parseMime(contentType);\n  if (mime.type !== \"text/csv\") {\n    throw new TypeError(`Invalid mime type: \"${contentType}\"`);\n  }\n\n  const contentEncoding = headers.get(\"content-encoding\");\n  let decompression: CompressionFormat | undefined;\n\n  if (contentEncoding) {\n    const normalizedEncoding = contentEncoding.trim().toLowerCase();\n\n    if (normalizedEncoding.includes(\",\")) {\n      throw new TypeError(\n        `Multiple content-encodings are not supported: \"${contentEncoding}\"`,\n      );\n    }\n\n    if (SUPPORTED_COMPRESSIONS.has(normalizedEncoding as CompressionFormat)) {\n      decompression = normalizedEncoding as CompressionFormat;\n    } else if (normalizedEncoding) {\n      // Unknown compression format\n      if (options.allowExperimentalCompressions) {\n        // Allow runtime to handle experimental/future formats\n        decompression = normalizedEncoding as CompressionFormat;\n      } else {\n        throw new TypeError(\n          `Unsupported content-encoding: \"${contentEncoding}\". Supported formats: ${Array.from(SUPPORTED_COMPRESSIONS).join(\", \")}. To use experimental formats, set allowExperimentalCompressions: true`,\n        );\n      }\n    }\n  }\n\n  const charset = mime.parameters.charset ?? \"utf-8\";\n  // TODO: Support header=present and header=absent\n  // const header = mime.parameters.header ?? \"present\";\n  return {\n    decompression,\n    charset,\n    ...options,\n  };\n}\n"],"names":[],"mappings":";;;AAaO,SAAS,qBAAA,CAKd,OAAA,EACA,OAAA,GAII,EAAC,EAC6C;AAClD,EAAA,MAAM,EAAE,SAAQ,GAAI,OAAA;AACpB,EAAA,MAAM,WAAA,GAAc,OAAA,CAAQ,GAAA,CAAI,cAAc,CAAA,IAAK,UAAA;AACnD,EAAA,MAAM,IAAA,GAAO,UAAU,WAAW,CAAA;AAClC,EAAA,IAAI,IAAA,CAAK,SAAS,UAAA,EAAY;AAC5B,IAAA,MAAM,IAAI,SAAA,CAAU,CAAA,oBAAA,EAAuB,WAAW,CAAA,CAAA,CAAG,CAAA;AAAA,EAC3D;AAEA,EAAA,MAAM,eAAA,GAAkB,OAAA,CAAQ,GAAA,CAAI,kBAAkB,CAAA;AACtD,EAAA,IAAI,aAAA;AAEJ,EAAA,IAAI,eAAA,EAAiB;AACnB,IAAA,MAAM,kBAAA,GAAqB,eAAA,CAAgB,IAAA,EAAK,CAAE,WAAA,EAAY;AAE9D,IAAA,IAAI,kBAAA,CAAmB,QAAA,CAAS,GAAG,CAAA,EAAG;AACpC,MAAA,MAAM,IAAI,SAAA;AAAA,QACR,kDAAkD,eAAe,CAAA,CAAA;AAAA,OACnE;AAAA,IACF;AAEA,IAAA,IAAI,sBAAA,CAAuB,GAAA,CAAI,kBAAuC,CAAA,EAAG;AACvE,MAAA,aAAA,GAAgB,kBAAA;AAAA,IAClB,WAAW,kBAAA,EAAoB;AAE7B,MAAA,IAAI,QAAQ,6BAAA,EAA+B;AAEzC,QAAA,aAAA,GAAgB,kBAAA;AAAA,MAClB,CAAA,MAAO;AACL,QAAA,MAAM,IAAI,SAAA;AAAA,UACR,CAAA,+BAAA,EAAkC,eAAe,CAAA,sBAAA,EAAyB,KAAA,CAAM,KAAK,sBAAsB,CAAA,CAAE,IAAA,CAAK,IAAI,CAAC,CAAA,sEAAA;AAAA,SACzH;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,EAAA,MAAM,OAAA,GAAU,IAAA,CAAK,UAAA,CAAW,OAAA,IAAW,OAAA;AAG3C,EAAA,OAAO;AAAA,IACL,aAAA;AAAA,IACA,OAAA;AAAA,IACA,GAAG;AAAA,GACL;AACF;;;;"}

package/dist/parse.d.ts

@@ -4,7 +4,7 @@ import { PickCSVHeader } from './utils/types.ts';
 /**
  * Parse CSV to records.
  *
- * {@link !String}, {@link !ReadableStream}<string | {@link !Uint8Array}> and {@link !Response} are supported.
+ * {@link !String}, {@link !ReadableStream}<string | {@link !Uint8Array}>, {@link !Response}, {@link !Request}, {@link !Blob}, and {@link !File} are supported.
  *
  *
  * @typeParam Header Header type like `['name', 'age']`.
@@ -18,7 +18,7 @@ import { PickCSVHeader } from './utils/types.ts';
  *
  * @remarks
  * {@link parseString}, {@link parseBinary}, {@link parseUint8ArrayStream},
- * {@link parseStringStream} and {@link parseResponse} are used internally.
+ * {@link parseStringStream}, {@link parseResponse}, {@link parseRequest}, and {@link parseBlob} are used internally.
  *
  * If you known the type of the CSV, it performs better to use them directly.
  *
@@ -29,6 +29,8 @@ import { PickCSVHeader } from './utils/types.ts';
  * | {@link !Uint8Array} \| {@link !ArrayBuffer}  | {@link parseBinary}           | {@link ParseBinaryOptions} |
  * | {@link !ReadableStream}<{@link !Uint8Array}> | {@link parseUint8ArrayStream} | {@link ParseBinaryOptions} |
  * | {@link !Response}                            | {@link parseResponse}         | {@link ParseBinaryOptions} |
+ * | {@link !Request}                             | {@link parseRequest}          | {@link ParseBinaryOptions} |
+ * | {@link !Blob} \| {@link !File}               | {@link parseBlob}             | {@link ParseBinaryOptions} |
  *
  * **Performance Characteristics:**
  * - **Memory usage**: O(1) - constant per record (streaming approach)

package/dist/parse.js

@@ -1,4 +1,6 @@
 import { parseBinary } from './parseBinary.js';
+import { parseBlob } from './parseBlob.js';
+import { parseRequest } from './parseRequest.js';
 import { parseResponse } from './parseResponse.js';
 import { parseString } from './parseString.js';
 import { parseStringStream } from './parseStringStream.js';
@@ -7,48 +9,28 @@ import { convertThisAsyncIterableIteratorToArray } from './utils/convertThisAsyn
 
 async function* parse(csv, options) {
   if (typeof csv === "string") {
-    const iterator = parseString(csv, options);
-    yield* iterator;
+    yield* parseString(csv, options);
   } else if (csv instanceof Uint8Array || csv instanceof ArrayBuffer) {
-    const iterator = parseBinary(csv, options);
-    if (iterator instanceof Promise) {
-      yield* await iterator;
-    } else {
-      yield* iterator;
-    }
+    yield* parseBinary(csv, options);
   } else if (csv instanceof ReadableStream) {
     const [branch1, branch2] = csv.tee();
     const reader1 = branch1.getReader();
     const { value: firstChunk } = await reader1.read();
     reader1.releaseLock();
     if (typeof firstChunk === "string") {
-      const iterator = parseStringStream(
-        branch2,
-        options
-      );
-      if (iterator instanceof Promise) {
-        yield* await iterator;
-      } else {
-        yield* iterator;
-      }
+      yield* parseStringStream(branch2, options);
     } else if (firstChunk instanceof Uint8Array) {
-      const iterator = parseUint8ArrayStream(
+      yield* parseUint8ArrayStream(
         branch2,
         options
       );
-      if (iterator instanceof Promise) {
-        yield* await iterator;
-      } else {
-        yield* iterator;
-      }
     }
   } else if (csv instanceof Response) {
-    const iterator = parseResponse(csv, options);
-    if (iterator instanceof Promise) {
-      yield* await iterator;
-    } else {
-      yield* iterator;
-    }
+    yield* parseResponse(csv, options);
+  } else if (csv instanceof Request) {
+    yield* parseRequest(csv, options);
+  } else if (csv instanceof Blob) {
+    yield* parseBlob(csv, options);
   }
 }
 Object.defineProperties(parse, {

package/dist/parse.js.map

@@ -1 +1 @@
-{"version":3,"file":"parse.js","sources":["../src/parse.ts"],"sourcesContent":["import type {\n  CSV,\n  CSVBinary,\n  CSVRecord,\n  CSVString,\n  ParseBinaryOptions,\n  ParseOptions,\n} from \"./common/types.ts\";\nimport type { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from \"./constants.ts\";\nimport { parseBinary } from \"./parseBinary.ts\";\nimport { parseResponse } from \"./parseResponse.ts\";\nimport { parseString } from \"./parseString.ts\";\nimport { parseStringStream } from \"./parseStringStream.ts\";\nimport { parseUint8ArrayStream } from \"./parseUint8ArrayStream.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\nimport type { PickCSVHeader } from \"./utils/types.ts\";\n\n/**\n * Parse CSV to records.\n *\n * {@link !String}, {@link !ReadableStream}<string | {@link !Uint8Array}> and {@link !Response} are supported.\n *\n *\n * @typeParam Header Header type like `['name', 'age']`.\n *\n * @param csv CSV string to parse.\n * @param options Parsing options for CSV string parsing.\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parse.toArray} function.\n * @category High-level API\n *\n * @remarks\n * {@link parseString}, {@link parseBinary}, {@link parseUint8ArrayStream},\n * {@link parseStringStream} and {@link parseResponse} are used internally.\n *\n * If you known the type of the CSV, it performs better to use them directly.\n *\n * | If you want to parse a...                    | Use...                        | Options...                 |\n * | -------------------------------------------- | ----------------------------- | -------------------------- |\n * | {@link !String}                              | {@link parseString}           | {@link ParseOptions}       |\n * | {@link !ReadableStream}<{@link !String}>     | {@link parseStringStream}     | {@link ParseOptions}       |\n * | {@link !Uint8Array} \\| {@link !ArrayBuffer}  | {@link parseBinary}           | {@link ParseBinaryOptions} |\n * | {@link !ReadableStream}<{@link !Uint8Array}> | {@link parseUint8ArrayStream} | {@link ParseBinaryOptions} |\n * | {@link !Response}                            | {@link parseResponse}         | {@link ParseBinaryOptions} |\n *\n * **Performance Characteristics:**\n * - **Memory usage**: O(1) - constant per record (streaming approach)\n * - **Suitable for**: Files of any size, browser and server environments\n * - **Recommended for**: Large files (> 10MB) or memory-constrained environments\n *\n * This function processes CSV data as an async iterable iterator, yielding one record at a time.\n * Memory footprint remains constant regardless of file size, making it ideal for large datasets.\n *\n * @example Parsing CSV files from strings\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * const csv = `name,age\n * Alice,42\n * Bob,69`;\n *\n * for await (const record of parse(csv)) {\n *   console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n *\n * @example Parsing CSV files from streams\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * const csv = `name,age\n * Alice,42\n * Bob,69`;\n *\n * const stream = new ReadableStream({\n *   start(controller) {\n *     controller.enqueue(csv);\n *     controller.close();\n *   }\n * });\n *\n * for await (const record of parse(stream)) {\n *  console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n *\n *\n * @example Parsing CSV files with headers\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * // This CSV has no header.\n * const csv = `Alice,42\n * Bob,69`;\n *\n * for await (const record of parse(csv, { header: ['name', 'age'] })) {\n *  console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n *\n * @example Parsing CSV files with different delimiters characters\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * const csv = `name\\tage\n * Alice\\t42\n * Bob\\t69`;\n *\n * for await (const record of parse(csv, { delimiter: '\\t' })) {\n * console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n */\nexport function parse<const CSVSource extends CSVString>(\n  csv: CSVSource,\n): AsyncIterableIterator<CSVRecord<PickCSVHeader<CSVSource>>>;\nexport function parse<const Header extends ReadonlyArray<string>>(\n  csv: CSVString,\n): AsyncIterableIterator<CSVRecord<Header>>;\nexport function parse<const Header extends ReadonlyArray<string>>(\n  csv: CSVString,\n  options: ParseOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>>;\nexport function parse<\n  const CSVSource extends CSVString,\n  const Delimiter extends string = DEFAULT_DELIMITER,\n  const Quotation extends string = DEFAULT_QUOTATION,\n  const Header extends ReadonlyArray<string> = PickCSVHeader<\n    CSVSource,\n    Delimiter,\n    Quotation\n  >,\n>(\n  csv: CSVSource,\n  options: ParseOptions<Header, Delimiter, Quotation>,\n): AsyncIterableIterator<CSVRecord<Header>>;\n/**\n * Parse CSV binary to records.\n *\n * @param csv CSV binary to parse.\n * @param options Parsing options for CSV binary parsing.\n *\n * @example Parsing CSV files from responses\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * // This CSV data is not gzipped and encoded in utf-8.\n * const response = await fetch('https://example.com/data.csv');\n *\n * for await (const record of parse(response)) {\n *   // ...\n * }\n * ```\n *\n * @example Parsing CSV files with options spcialized for binary\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * // This CSV data is gzipped and encoded in shift-jis and has BOM.\n * const response = await fetch('https://example.com/data.csv.gz');\n *\n * for await (const record of parse(response, {\n *   charset: 'shift-jis',\n *   ignoreBOM: true,\n *   decompression: 'gzip',\n * })) {\n *   // ...\n * }\n * ```\n */\nexport function parse<const Header extends ReadonlyArray<string>>(\n  csv: CSVBinary,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>>;\nexport async function* parse<const Header extends ReadonlyArray<string>>(\n  csv: CSV,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  if (typeof csv === \"string\") {\n    const iterator = parseString(csv, options);\n    yield* iterator;\n  } else if (csv instanceof Uint8Array || csv instanceof ArrayBuffer) {\n    const iterator = parseBinary(csv, options);\n    // Check if it's a Promise\n    if (iterator instanceof Promise) {\n      yield* await iterator;\n    } else {\n      yield* iterator;\n    }\n  } else if (csv instanceof ReadableStream) {\n    const [branch1, branch2] = csv.tee();\n    const reader1 = branch1.getReader();\n    const { value: firstChunk } = await reader1.read();\n    reader1.releaseLock();\n    if (typeof firstChunk === \"string\") {\n      const iterator = parseStringStream(\n        branch2 as ReadableStream<string>,\n        options,\n      );\n      // Check if it's a Promise\n      if (iterator instanceof Promise) {\n        yield* await iterator;\n      } else {\n        yield* iterator;\n      }\n    } else if (firstChunk instanceof Uint8Array) {\n      const iterator = parseUint8ArrayStream(\n        branch2 as ReadableStream<Uint8Array>,\n        options,\n      );\n      // Check if it's a Promise\n      if (iterator instanceof Promise) {\n        yield* await iterator;\n      } else {\n        yield* iterator;\n      }\n    }\n  } else if (csv instanceof Response) {\n    const iterator = parseResponse(csv, options);\n    // Check if it's a Promise\n    if (iterator instanceof Promise) {\n      yield* await iterator;\n    } else {\n      yield* iterator;\n    }\n  }\n}\n\nexport declare namespace parse {\n  /**\n   * Parse CSV string to array of records,\n   * ideal for smaller data sets.\n   *\n   * @remarks\n   * **Performance Characteristics:**\n   * - **Memory usage**: O(n) - proportional to file size (loads entire result into memory)\n   * - **Suitable for**: Small datasets, quick prototyping\n   * - **Recommended max**: ~10MB (browser), ~100MB (Node.js/Deno)\n   *\n   * This function collects all records into an array before returning.\n   * For large files, consider using the streaming {@link parse} function instead.\n   *\n   * @example Parse a CSV as array of records\n   *\n   * ```ts\n   * import { parse } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const records = await parse.toArray(csv);\n   * console.log(records);\n   * // Prints:\n   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    csv: CSVString,\n    options?: ParseOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV binary to array of records,\n   * ideal for smaller data sets.\n   *\n   * @remarks\n   * **Performance Characteristics:**\n   * - **Memory usage**: O(n) - proportional to file size (loads entire result into memory)\n   * - **Suitable for**: Small datasets, quick prototyping\n   * - **Recommended max**: ~10MB (browser), ~100MB (Node.js/Deno)\n   *\n   * This function collects all records into an array before returning.\n   * For large files, consider using the streaming {@link parse} function instead.\n   *\n   * @example Parse a CSV as array of records\n   *\n   * ```ts\n   * import { parse } from 'web-csv-toolbox';\n   *\n   * const response = await fetch('https://example.com/data.csv');\n   *\n   * const records = await parse.toArray(response);\n   * console.log(records);\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    csv: CSVBinary,\n    options?: ParseBinaryOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n}\n\nObject.defineProperties(parse, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n});\n"],"names":["internal.convertThisAsyncIterableIteratorToArray"],"mappings":";;;;;;;AAiMA,gBAAuB,KAAA,CACrB,KACA,OAAA,EAC0C;AAC1C,EAAA,IAAI,OAAO,QAAQ,QAAA,EAAU;AAC3B,IAAA,MAAM,QAAA,GAAW,WAAA,CAAY,GAAA,EAAK,OAAO,CAAA;AACzC,IAAA,OAAO,QAAA;AAAA,EACT,CAAA,MAAA,IAAW,GAAA,YAAe,UAAA,IAAc,GAAA,YAAe,WAAA,EAAa;AAClE,IAAA,MAAM,QAAA,GAAW,WAAA,CAAY,GAAA,EAAK,OAAO,CAAA;AAEzC,IAAA,IAAI,oBAAoB,OAAA,EAAS;AAC/B,MAAA,OAAO,MAAM,QAAA;AAAA,IACf,CAAA,MAAO;AACL,MAAA,OAAO,QAAA;AAAA,IACT;AAAA,EACF,CAAA,MAAA,IAAW,eAAe,cAAA,EAAgB;AACxC,IAAA,MAAM,CAAC,OAAA,EAAS,OAAO,CAAA,GAAI,IAAI,GAAA,EAAI;AACnC,IAAA,MAAM,OAAA,GAAU,QAAQ,SAAA,EAAU;AAClC,IAAA,MAAM,EAAE,KAAA,EAAO,UAAA,EAAW,GAAI,MAAM,QAAQ,IAAA,EAAK;AACjD,IAAA,OAAA,CAAQ,WAAA,EAAY;AACpB,IAAA,IAAI,OAAO,eAAe,QAAA,EAAU;AAClC,MAAA,MAAM,QAAA,GAAW,iBAAA;AAAA,QACf,OAAA;AAAA,QACA;AAAA,OACF;AAEA,MAAA,IAAI,oBAAoB,OAAA,EAAS;AAC/B,QAAA,OAAO,MAAM,QAAA;AAAA,MACf,CAAA,MAAO;AACL,QAAA,OAAO,QAAA;AAAA,MACT;AAAA,IACF,CAAA,MAAA,IAAW,sBAAsB,UAAA,EAAY;AAC3C,MAAA,MAAM,QAAA,GAAW,qBAAA;AAAA,QACf,OAAA;AAAA,QACA;AAAA,OACF;AAEA,MAAA,IAAI,oBAAoB,OAAA,EAAS;AAC/B,QAAA,OAAO,MAAM,QAAA;AAAA,MACf,CAAA,MAAO;AACL,QAAA,OAAO,QAAA;AAAA,MACT;AAAA,IACF;AAAA,EACF,CAAA,MAAA,IAAW,eAAe,QAAA,EAAU;AAClC,IAAA,MAAM,QAAA,GAAW,aAAA,CAAc,GAAA,EAAK,OAAO,CAAA;AAE3C,IAAA,IAAI,oBAAoB,OAAA,EAAS;AAC/B,MAAA,OAAO,MAAM,QAAA;AAAA,IACf,CAAA,MAAO;AACL,MAAA,OAAO,QAAA;AAAA,IACT;AAAA,EACF;AACF;AAiEA,MAAA,CAAO,iBAAiB,KAAA,EAAO;AAAA,EAC7B,OAAA,EAAS;AAAA,IACP,UAAA,EAAY,IAAA;AAAA,IACZ,QAAA,EAAU,KAAA;AAAA,IACV,OAAOA;AAAS;AAEpB,CAAC,CAAA;;;;"}
+{"version":3,"file":"parse.js","sources":["../src/parse.ts"],"sourcesContent":["import type {\n  CSV,\n  CSVBinary,\n  CSVRecord,\n  CSVString,\n  ParseBinaryOptions,\n  ParseOptions,\n} from \"./common/types.ts\";\nimport type { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from \"./constants.ts\";\nimport { parseBinary } from \"./parseBinary.ts\";\nimport { parseBlob } from \"./parseBlob.ts\";\nimport { parseRequest } from \"./parseRequest.ts\";\nimport { parseResponse } from \"./parseResponse.ts\";\nimport { parseString } from \"./parseString.ts\";\nimport { parseStringStream } from \"./parseStringStream.ts\";\nimport { parseUint8ArrayStream } from \"./parseUint8ArrayStream.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\nimport type { PickCSVHeader } from \"./utils/types.ts\";\n\n/**\n * Parse CSV to records.\n *\n * {@link !String}, {@link !ReadableStream}<string | {@link !Uint8Array}>, {@link !Response}, {@link !Request}, {@link !Blob}, and {@link !File} are supported.\n *\n *\n * @typeParam Header Header type like `['name', 'age']`.\n *\n * @param csv CSV string to parse.\n * @param options Parsing options for CSV string parsing.\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parse.toArray} function.\n * @category High-level API\n *\n * @remarks\n * {@link parseString}, {@link parseBinary}, {@link parseUint8ArrayStream},\n * {@link parseStringStream}, {@link parseResponse}, {@link parseRequest}, and {@link parseBlob} are used internally.\n *\n * If you known the type of the CSV, it performs better to use them directly.\n *\n * | If you want to parse a...                    | Use...                        | Options...                 |\n * | -------------------------------------------- | ----------------------------- | -------------------------- |\n * | {@link !String}                              | {@link parseString}           | {@link ParseOptions}       |\n * | {@link !ReadableStream}<{@link !String}>     | {@link parseStringStream}     | {@link ParseOptions}       |\n * | {@link !Uint8Array} \\| {@link !ArrayBuffer}  | {@link parseBinary}           | {@link ParseBinaryOptions} |\n * | {@link !ReadableStream}<{@link !Uint8Array}> | {@link parseUint8ArrayStream} | {@link ParseBinaryOptions} |\n * | {@link !Response}                            | {@link parseResponse}         | {@link ParseBinaryOptions} |\n * | {@link !Request}                             | {@link parseRequest}          | {@link ParseBinaryOptions} |\n * | {@link !Blob} \\| {@link !File}               | {@link parseBlob}             | {@link ParseBinaryOptions} |\n *\n * **Performance Characteristics:**\n * - **Memory usage**: O(1) - constant per record (streaming approach)\n * - **Suitable for**: Files of any size, browser and server environments\n * - **Recommended for**: Large files (> 10MB) or memory-constrained environments\n *\n * This function processes CSV data as an async iterable iterator, yielding one record at a time.\n * Memory footprint remains constant regardless of file size, making it ideal for large datasets.\n *\n * @example Parsing CSV files from strings\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * const csv = `name,age\n * Alice,42\n * Bob,69`;\n *\n * for await (const record of parse(csv)) {\n *   console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n *\n * @example Parsing CSV files from streams\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * const csv = `name,age\n * Alice,42\n * Bob,69`;\n *\n * const stream = new ReadableStream({\n *   start(controller) {\n *     controller.enqueue(csv);\n *     controller.close();\n *   }\n * });\n *\n * for await (const record of parse(stream)) {\n *  console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n *\n *\n * @example Parsing CSV files with headers\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * // This CSV has no header.\n * const csv = `Alice,42\n * Bob,69`;\n *\n * for await (const record of parse(csv, { header: ['name', 'age'] })) {\n *  console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n *\n * @example Parsing CSV files with different delimiters characters\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * const csv = `name\\tage\n * Alice\\t42\n * Bob\\t69`;\n *\n * for await (const record of parse(csv, { delimiter: '\\t' })) {\n * console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n */\nexport function parse<const CSVSource extends CSVString>(\n  csv: CSVSource,\n): AsyncIterableIterator<CSVRecord<PickCSVHeader<CSVSource>>>;\nexport function parse<const Header extends ReadonlyArray<string>>(\n  csv: CSVString,\n): AsyncIterableIterator<CSVRecord<Header>>;\nexport function parse<const Header extends ReadonlyArray<string>>(\n  csv: CSVString,\n  options: ParseOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>>;\nexport function parse<\n  const CSVSource extends CSVString,\n  const Delimiter extends string = DEFAULT_DELIMITER,\n  const Quotation extends string = DEFAULT_QUOTATION,\n  const Header extends ReadonlyArray<string> = PickCSVHeader<\n    CSVSource,\n    Delimiter,\n    Quotation\n  >,\n>(\n  csv: CSVSource,\n  options: ParseOptions<Header, Delimiter, Quotation>,\n): AsyncIterableIterator<CSVRecord<Header>>;\n/**\n * Parse CSV binary to records.\n *\n * @param csv CSV binary to parse.\n * @param options Parsing options for CSV binary parsing.\n *\n * @example Parsing CSV files from responses\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * // This CSV data is not gzipped and encoded in utf-8.\n * const response = await fetch('https://example.com/data.csv');\n *\n * for await (const record of parse(response)) {\n *   // ...\n * }\n * ```\n *\n * @example Parsing CSV files with options spcialized for binary\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * // This CSV data is gzipped and encoded in shift-jis and has BOM.\n * const response = await fetch('https://example.com/data.csv.gz');\n *\n * for await (const record of parse(response, {\n *   charset: 'shift-jis',\n *   ignoreBOM: true,\n *   decompression: 'gzip',\n * })) {\n *   // ...\n * }\n * ```\n */\nexport function parse<const Header extends ReadonlyArray<string>>(\n  csv: CSVBinary,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>>;\nexport async function* parse<const Header extends ReadonlyArray<string>>(\n  csv: CSV,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  if (typeof csv === \"string\") {\n    yield* parseString(csv, options);\n  } else if (csv instanceof Uint8Array || csv instanceof ArrayBuffer) {\n    yield* parseBinary(csv, options);\n  } else if (csv instanceof ReadableStream) {\n    const [branch1, branch2] = csv.tee();\n    const reader1 = branch1.getReader();\n    const { value: firstChunk } = await reader1.read();\n    reader1.releaseLock();\n    if (typeof firstChunk === \"string\") {\n      yield* parseStringStream(branch2 as ReadableStream<string>, options);\n    } else if (firstChunk instanceof Uint8Array) {\n      yield* parseUint8ArrayStream(\n        branch2 as ReadableStream<Uint8Array>,\n        options,\n      );\n    }\n  } else if (csv instanceof Response) {\n    yield* parseResponse(csv, options);\n  } else if (csv instanceof Request) {\n    yield* parseRequest(csv, options);\n  } else if (csv instanceof Blob) {\n    yield* parseBlob(csv, options);\n  }\n}\n\nexport declare namespace parse {\n  /**\n   * Parse CSV string to array of records,\n   * ideal for smaller data sets.\n   *\n   * @remarks\n   * **Performance Characteristics:**\n   * - **Memory usage**: O(n) - proportional to file size (loads entire result into memory)\n   * - **Suitable for**: Small datasets, quick prototyping\n   * - **Recommended max**: ~10MB (browser), ~100MB (Node.js/Deno)\n   *\n   * This function collects all records into an array before returning.\n   * For large files, consider using the streaming {@link parse} function instead.\n   *\n   * @example Parse a CSV as array of records\n   *\n   * ```ts\n   * import { parse } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const records = await parse.toArray(csv);\n   * console.log(records);\n   * // Prints:\n   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    csv: CSVString,\n    options?: ParseOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV binary to array of records,\n   * ideal for smaller data sets.\n   *\n   * @remarks\n   * **Performance Characteristics:**\n   * - **Memory usage**: O(n) - proportional to file size (loads entire result into memory)\n   * - **Suitable for**: Small datasets, quick prototyping\n   * - **Recommended max**: ~10MB (browser), ~100MB (Node.js/Deno)\n   *\n   * This function collects all records into an array before returning.\n   * For large files, consider using the streaming {@link parse} function instead.\n   *\n   * @example Parse a CSV as array of records\n   *\n   * ```ts\n   * import { parse } from 'web-csv-toolbox';\n   *\n   * const response = await fetch('https://example.com/data.csv');\n   *\n   * const records = await parse.toArray(response);\n   * console.log(records);\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    csv: CSVBinary,\n    options?: ParseBinaryOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n}\n\nObject.defineProperties(parse, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n});\n"],"names":["internal.convertThisAsyncIterableIteratorToArray"],"mappings":";;;;;;;;;AAqMA,gBAAuB,KAAA,CACrB,KACA,OAAA,EAC0C;AAC1C,EAAA,IAAI,OAAO,QAAQ,QAAA,EAAU;AAC3B,IAAA,OAAO,WAAA,CAAY,KAAK,OAAO,CAAA;AAAA,EACjC,CAAA,MAAA,IAAW,GAAA,YAAe,UAAA,IAAc,GAAA,YAAe,WAAA,EAAa;AAClE,IAAA,OAAO,WAAA,CAAY,KAAK,OAAO,CAAA;AAAA,EACjC,CAAA,MAAA,IAAW,eAAe,cAAA,EAAgB;AACxC,IAAA,MAAM,CAAC,OAAA,EAAS,OAAO,CAAA,GAAI,IAAI,GAAA,EAAI;AACnC,IAAA,MAAM,OAAA,GAAU,QAAQ,SAAA,EAAU;AAClC,IAAA,MAAM,EAAE,KAAA,EAAO,UAAA,EAAW,GAAI,MAAM,QAAQ,IAAA,EAAK;AACjD,IAAA,OAAA,CAAQ,WAAA,EAAY;AACpB,IAAA,IAAI,OAAO,eAAe,QAAA,EAAU;AAClC,MAAA,OAAO,iBAAA,CAAkB,SAAmC,OAAO,CAAA;AAAA,IACrE,CAAA,MAAA,IAAW,sBAAsB,UAAA,EAAY;AAC3C,MAAA,OAAO,qBAAA;AAAA,QACL,OAAA;AAAA,QACA;AAAA,OACF;AAAA,IACF;AAAA,EACF,CAAA,MAAA,IAAW,eAAe,QAAA,EAAU;AAClC,IAAA,OAAO,aAAA,CAAc,KAAK,OAAO,CAAA;AAAA,EACnC,CAAA,MAAA,IAAW,eAAe,OAAA,EAAS;AACjC,IAAA,OAAO,YAAA,CAAa,KAAK,OAAO,CAAA;AAAA,EAClC,CAAA,MAAA,IAAW,eAAe,IAAA,EAAM;AAC9B,IAAA,OAAO,SAAA,CAAU,KAAK,OAAO,CAAA;AAAA,EAC/B;AACF;AAiEA,MAAA,CAAO,iBAAiB,KAAA,EAAO;AAAA,EAC7B,OAAA,EAAS;AAAA,IACP,UAAA,EAAY,IAAA;AAAA,IACZ,QAAA,EAAU,KAAA;AAAA,IACV,OAAOA;AAAS;AAEpB,CAAC,CAAA;;;;"}

package/dist/parseBlob.d.ts

@@ -0,0 +1,102 @@
+import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
+/**
+ * Parse CSV from a {@link !Blob} or {@link !File} to records.
+ *
+ * @remarks
+ * This function can parse CSV data from Blob or File objects.
+ * If the Blob has a type with charset parameter, it will be used for decoding.
+ *
+ * File objects (from file inputs or drag-and-drop) extend Blob and are automatically supported.
+ *
+ * @category Middle-level API
+ * @param blob - The blob or file to parse
+ * @param options - Parsing options
+ * @returns Async iterable iterator of records.
+ *
+ * If you want array of records, use {@link parseBlob.toArray} function.
+ *
+ * @example Parsing CSV from Blob
+ *
+ * ```ts
+ * import { parseBlob } from 'web-csv-toolbox';
+ *
+ * const blob = new Blob(['name,age\nAlice,42\nBob,69'], { type: 'text/csv' });
+ *
+ * for await (const record of parseBlob(blob)) {
+ *   console.log(record);
+ * }
+ * ```
+ *
+ * @example Parsing CSV from File (input element)
+ *
+ * ```ts
+ * import { parseBlob } from 'web-csv-toolbox';
+ *
+ * const input = document.querySelector('input[type="file"]');
+ * input.addEventListener('change', async (event) => {
+ *   const file = event.target.files[0];
+ *   for await (const record of parseBlob(file)) {
+ *     console.log(record);
+ *   }
+ * });
+ * ```
+ *
+ * @example Parsing CSV from Blob with charset
+ *
+ * ```ts
+ * import { parseBlob } from 'web-csv-toolbox';
+ *
+ * const blob = new Blob([csvData], { type: 'text/csv;charset=shift-jis' });
+ *
+ * for await (const record of parseBlob(blob)) {
+ *   console.log(record);
+ * }
+ * ```
+ */
+export declare function parseBlob<Header extends ReadonlyArray<string>>(blob: Blob, options?: ParseBinaryOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
+export declare namespace parseBlob {
+    /**
+     * Parse CSV from a {@link !Blob} or {@link !File} to array of records.
+     *
+     * @returns Array of records
+     *
+     * @example Parsing CSV from Blob
+     *
+     * ```ts
+     * import { parseBlob } from 'web-csv-toolbox';
+     *
+     * const blob = new Blob(['name,age\nAlice,42\nBob,69'], { type: 'text/csv' });
+     *
+     * const records = await parseBlob.toArray(blob);
+     * console.log(records);
+     * ```
+     */
+    function toArray<Header extends ReadonlyArray<string>>(blob: Blob, options?: ParseBinaryOptions<Header>): Promise<CSVRecord<Header>[]>;
+    /**
+     * Parse CSV from a {@link !Blob} or {@link !File} to stream of records.
+     *
+     * @param blob - Blob or File to parse
+     * @returns Stream of records
+     *
+     * @example Parsing CSV from Blob
+     *
+     * ```ts
+     * import { parseBlob } from 'web-csv-toolbox';
+     *
+     * const blob = new Blob(['name,age\nAlice,42\nBob,69'], { type: 'text/csv' });
+     *
+     * await parseBlob.toStream(blob)
+     *   .pipeTo(
+     *     new WritableStream({
+     *       write(record) {
+     *         console.log(record);
+     *       },
+     *    }),
+     * );
+     * // Prints:
+     * // { name: 'Alice', age: '42' }
+     * // { name: 'Bob', age: '69' }
+     * ```
+     */
+    function toStream<Header extends ReadonlyArray<string>>(blob: Blob, options?: ParseBinaryOptions<Header>): ReadableStream<CSVRecord<Header>>;
+}

package/dist/parseBlob.js

@@ -0,0 +1,31 @@
+import { commonParseErrorHandling } from './commonParseErrorHandling.js';
+import { getOptionsFromBlob } from './getOptionsFromBlob.js';
+import { parseBlobToStream } from './parseBlobToStream.js';
+import { parseUint8ArrayStream } from './parseUint8ArrayStream.js';
+import { convertThisAsyncIterableIteratorToArray } from './utils/convertThisAsyncIterableIteratorToArray.js';
+
+function parseBlob(blob, options) {
+  const options_ = getOptionsFromBlob(blob, options);
+  return (async function* () {
+    try {
+      yield* parseUint8ArrayStream(blob.stream(), options_);
+    } catch (error) {
+      commonParseErrorHandling(error);
+    }
+  })();
+}
+Object.defineProperties(parseBlob, {
+  toArray: {
+    enumerable: true,
+    writable: false,
+    value: convertThisAsyncIterableIteratorToArray
+  },
+  toStream: {
+    enumerable: true,
+    writable: false,
+    value: parseBlobToStream
+  }
+});
+
+export { parseBlob };
+//# sourceMappingURL=parseBlob.js.map

package/dist/parseBlob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseBlob.js","sources":["../src/parseBlob.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { commonParseErrorHandling } from \"./commonParseErrorHandling.ts\";\nimport { getOptionsFromBlob } from \"./getOptionsFromBlob.ts\";\nimport { parseBlobToStream } from \"./parseBlobToStream.ts\";\nimport { parseUint8ArrayStream } from \"./parseUint8ArrayStream.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse CSV from a {@link !Blob} or {@link !File} to records.\n *\n * @remarks\n * This function can parse CSV data from Blob or File objects.\n * If the Blob has a type with charset parameter, it will be used for decoding.\n *\n * File objects (from file inputs or drag-and-drop) extend Blob and are automatically supported.\n *\n * @category Middle-level API\n * @param blob - The blob or file to parse\n * @param options - Parsing options\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parseBlob.toArray} function.\n *\n * @example Parsing CSV from Blob\n *\n * ```ts\n * import { parseBlob } from 'web-csv-toolbox';\n *\n * const blob = new Blob(['name,age\\nAlice,42\\nBob,69'], { type: 'text/csv' });\n *\n * for await (const record of parseBlob(blob)) {\n *   console.log(record);\n * }\n * ```\n *\n * @example Parsing CSV from File (input element)\n *\n * ```ts\n * import { parseBlob } from 'web-csv-toolbox';\n *\n * const input = document.querySelector('input[type=\"file\"]');\n * input.addEventListener('change', async (event) => {\n *   const file = event.target.files[0];\n *   for await (const record of parseBlob(file)) {\n *     console.log(record);\n *   }\n * });\n * ```\n *\n * @example Parsing CSV from Blob with charset\n *\n * ```ts\n * import { parseBlob } from 'web-csv-toolbox';\n *\n * const blob = new Blob([csvData], { type: 'text/csv;charset=shift-jis' });\n *\n * for await (const record of parseBlob(blob)) {\n *   console.log(record);\n * }\n * ```\n */\nexport function parseBlob<Header extends ReadonlyArray<string>>(\n  blob: Blob,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  // Extract options from blob\n  const options_ = getOptionsFromBlob(blob, options);\n\n  // Return wrapper async generator for error handling\n  return (async function* () {\n    try {\n      yield* parseUint8ArrayStream(blob.stream(), options_);\n    } catch (error) {\n      commonParseErrorHandling(error);\n    }\n  })();\n}\n\nexport declare namespace parseBlob {\n  /**\n   * Parse CSV from a {@link !Blob} or {@link !File} to array of records.\n   *\n   * @returns Array of records\n   *\n   * @example Parsing CSV from Blob\n   *\n   * ```ts\n   * import { parseBlob } from 'web-csv-toolbox';\n   *\n   * const blob = new Blob(['name,age\\nAlice,42\\nBob,69'], { type: 'text/csv' });\n   *\n   * const records = await parseBlob.toArray(blob);\n   * console.log(records);\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    blob: Blob,\n    options?: ParseBinaryOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV from a {@link !Blob} or {@link !File} to stream of records.\n   *\n   * @param blob - Blob or File to parse\n   * @returns Stream of records\n   *\n   * @example Parsing CSV from Blob\n   *\n   * ```ts\n   * import { parseBlob } from 'web-csv-toolbox';\n   *\n   * const blob = new Blob(['name,age\\nAlice,42\\nBob,69'], { type: 'text/csv' });\n   *\n   * await parseBlob.toStream(blob)\n   *   .pipeTo(\n   *     new WritableStream({\n   *       write(record) {\n   *         console.log(record);\n   *       },\n   *    }),\n   * );\n   * // Prints:\n   * // { name: 'Alice', age: '42' }\n   * // { name: 'Bob', age: '69' }\n   * ```\n   */\n  export function toStream<Header extends ReadonlyArray<string>>(\n    blob: Blob,\n    options?: ParseBinaryOptions<Header>,\n  ): ReadableStream<CSVRecord<Header>>;\n}\n\nObject.defineProperties(parseBlob, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n  toStream: {\n    enumerable: true,\n    writable: false,\n    value: parseBlobToStream,\n  },\n});\n"],"names":["internal.convertThisAsyncIterableIteratorToArray"],"mappings":";;;;;;AA6DO,SAAS,SAAA,CACd,MACA,OAAA,EAC0C;AAE1C,EAAA,MAAM,QAAA,GAAW,kBAAA,CAAmB,IAAA,EAAM,OAAO,CAAA;AAGjD,EAAA,OAAA,CAAQ,mBAAmB;AACzB,IAAA,IAAI;AACF,MAAA,OAAO,qBAAA,CAAsB,IAAA,CAAK,MAAA,EAAO,EAAG,QAAQ,CAAA;AAAA,IACtD,SAAS,KAAA,EAAO;AACd,MAAA,wBAAA,CAAyB,KAAK,CAAA;AAAA,IAChC;AAAA,EACF,CAAA,GAAG;AACL;AAuDA,MAAA,CAAO,iBAAiB,SAAA,EAAW;AAAA,EACjC,OAAA,EAAS;AAAA,IACP,UAAA,EAAY,IAAA;AAAA,IACZ,QAAA,EAAU,KAAA;AAAA,IACV,OAAOA;AAAS,GAClB;AAAA,EACA,QAAA,EAAU;AAAA,IACR,UAAA,EAAY,IAAA;AAAA,IACZ,QAAA,EAAU,KAAA;AAAA,IACV,KAAA,EAAO;AAAA;AAEX,CAAC,CAAA;;;;"}

package/dist/parseBlobToStream.d.ts

@@ -0,0 +1,11 @@
+import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
+/**
+ * Parse CSV from a {@link !Blob} or {@link !File} to stream of records.
+ *
+ * @param blob - Blob or File to parse
+ * @param options - Parsing options
+ * @returns Stream of records
+ *
+ * @category Middle-level API
+ */
+export declare function parseBlobToStream<Header extends ReadonlyArray<string>>(blob: Blob, options?: ParseBinaryOptions<Header>): ReadableStream<CSVRecord<Header>>;

package/dist/parseBlobToStream.js

@@ -0,0 +1,10 @@
+import { getOptionsFromBlob } from './getOptionsFromBlob.js';
+import { parseUint8ArrayStreamToStream } from './parseUint8ArrayStreamToStream.js';
+
+function parseBlobToStream(blob, options) {
+  const options_ = getOptionsFromBlob(blob, options);
+  return parseUint8ArrayStreamToStream(blob.stream(), options_);
+}
+
+export { parseBlobToStream };
+//# sourceMappingURL=parseBlobToStream.js.map

package/dist/parseBlobToStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseBlobToStream.js","sources":["../src/parseBlobToStream.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { getOptionsFromBlob } from \"./getOptionsFromBlob.ts\";\nimport { parseUint8ArrayStreamToStream } from \"./parseUint8ArrayStreamToStream.ts\";\n\n/**\n * Parse CSV from a {@link !Blob} or {@link !File} to stream of records.\n *\n * @param blob - Blob or File to parse\n * @param options - Parsing options\n * @returns Stream of records\n *\n * @category Middle-level API\n */\nexport function parseBlobToStream<Header extends ReadonlyArray<string>>(\n  blob: Blob,\n  options?: ParseBinaryOptions<Header>,\n): ReadableStream<CSVRecord<Header>> {\n  const options_ = getOptionsFromBlob(blob, options);\n  return parseUint8ArrayStreamToStream(blob.stream(), options_);\n}\n"],"names":[],"mappings":";;;AAaO,SAAS,iBAAA,CACd,MACA,OAAA,EACmC;AACnC,EAAA,MAAM,QAAA,GAAW,kBAAA,CAAmB,IAAA,EAAM,OAAO,CAAA;AACjD,EAAA,OAAO,6BAAA,CAA8B,IAAA,CAAK,MAAA,EAAO,EAAG,QAAQ,CAAA;AAC9D;;;;"}

package/dist/parseFile.d.ts

@@ -0,0 +1,93 @@
+import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
+/**
+ * Parse CSV from a {@link !File} to records.
+ *
+ * @remarks
+ * This is an alias for {@link parseBlob} since File extends Blob.
+ *
+ * This function can parse CSV data from File objects (from file inputs or drag-and-drop).
+ * If the File has a type with charset parameter, it will be used for decoding.
+ *
+ * @category Middle-level API
+ * @param file - The file to parse
+ * @param options - Parsing options
+ * @returns Async iterable iterator of records.
+ *
+ * If you want array of records, use {@link parseFile.toArray} function.
+ *
+ * @example Parsing CSV from File (input element)
+ *
+ * ```ts
+ * import { parseFile } from 'web-csv-toolbox';
+ *
+ * const input = document.querySelector('input[type="file"]');
+ * input.addEventListener('change', async (event) => {
+ *   const file = event.target.files[0];
+ *   for await (const record of parseFile(file)) {
+ *     console.log(record);
+ *   }
+ * });
+ * ```
+ *
+ * @example Parsing CSV from File (drag-and-drop)
+ *
+ * ```ts
+ * import { parseFile } from 'web-csv-toolbox';
+ *
+ * dropZone.addEventListener('drop', async (event) => {
+ *   event.preventDefault();
+ *   const file = event.dataTransfer.files[0];
+ *   for await (const record of parseFile(file)) {
+ *     console.log(record);
+ *   }
+ * });
+ * ```
+ */
+export declare function parseFile<Header extends ReadonlyArray<string>>(file: File, options?: ParseBinaryOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
+export declare namespace parseFile {
+    /**
+     * Parse CSV from a {@link !File} to array of records.
+     *
+     * @returns Array of records
+     *
+     * @example Parsing CSV from File
+     *
+     * ```ts
+     * import { parseFile } from 'web-csv-toolbox';
+     *
+     * const input = document.querySelector('input[type="file"]');
+     * input.addEventListener('change', async (event) => {
+     *   const file = event.target.files[0];
+     *   const records = await parseFile.toArray(file);
+     *   console.log(records);
+     * });
+     * ```
+     */
+    function toArray<Header extends ReadonlyArray<string>>(file: File, options?: ParseBinaryOptions<Header>): Promise<CSVRecord<Header>[]>;
+    /**
+     * Parse CSV from a {@link !File} to stream of records.
+     *
+     * @param file - File to parse
+     * @returns Stream of records
+     *
+     * @example Parsing CSV from File
+     *
+     * ```ts
+     * import { parseFile } from 'web-csv-toolbox';
+     *
+     * const input = document.querySelector('input[type="file"]');
+     * input.addEventListener('change', async (event) => {
+     *   const file = event.target.files[0];
+     *   await parseFile.toStream(file)
+     *     .pipeTo(
+     *       new WritableStream({
+     *         write(record) {
+     *           console.log(record);
+     *         },
+     *      }),
+     *   );
+     * });
+     * ```
+     */
+    function toStream<Header extends ReadonlyArray<string>>(file: File, options?: ParseBinaryOptions<Header>): ReadableStream<CSVRecord<Header>>;
+}

package/dist/parseFile.js

@@ -0,0 +1,20 @@
+import { parseBlob } from './parseBlob.js';
+
+function parseFile(file, options) {
+  return parseBlob(file, options);
+}
+Object.defineProperties(parseFile, {
+  toArray: {
+    enumerable: true,
+    writable: false,
+    value: parseBlob.toArray
+  },
+  toStream: {
+    enumerable: true,
+    writable: false,
+    value: parseBlob.toStream
+  }
+});
+
+export { parseFile };
+//# sourceMappingURL=parseFile.js.map

package/dist/parseFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseFile.js","sources":["../src/parseFile.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { parseBlob } from \"./parseBlob.ts\";\n\n/**\n * Parse CSV from a {@link !File} to records.\n *\n * @remarks\n * This is an alias for {@link parseBlob} since File extends Blob.\n *\n * This function can parse CSV data from File objects (from file inputs or drag-and-drop).\n * If the File has a type with charset parameter, it will be used for decoding.\n *\n * @category Middle-level API\n * @param file - The file to parse\n * @param options - Parsing options\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parseFile.toArray} function.\n *\n * @example Parsing CSV from File (input element)\n *\n * ```ts\n * import { parseFile } from 'web-csv-toolbox';\n *\n * const input = document.querySelector('input[type=\"file\"]');\n * input.addEventListener('change', async (event) => {\n *   const file = event.target.files[0];\n *   for await (const record of parseFile(file)) {\n *     console.log(record);\n *   }\n * });\n * ```\n *\n * @example Parsing CSV from File (drag-and-drop)\n *\n * ```ts\n * import { parseFile } from 'web-csv-toolbox';\n *\n * dropZone.addEventListener('drop', async (event) => {\n *   event.preventDefault();\n *   const file = event.dataTransfer.files[0];\n *   for await (const record of parseFile(file)) {\n *     console.log(record);\n *   }\n * });\n * ```\n */\nexport function parseFile<Header extends ReadonlyArray<string>>(\n  file: File,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  return parseBlob(file, options);\n}\n\nexport declare namespace parseFile {\n  /**\n   * Parse CSV from a {@link !File} to array of records.\n   *\n   * @returns Array of records\n   *\n   * @example Parsing CSV from File\n   *\n   * ```ts\n   * import { parseFile } from 'web-csv-toolbox';\n   *\n   * const input = document.querySelector('input[type=\"file\"]');\n   * input.addEventListener('change', async (event) => {\n   *   const file = event.target.files[0];\n   *   const records = await parseFile.toArray(file);\n   *   console.log(records);\n   * });\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    file: File,\n    options?: ParseBinaryOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV from a {@link !File} to stream of records.\n   *\n   * @param file - File to parse\n   * @returns Stream of records\n   *\n   * @example Parsing CSV from File\n   *\n   * ```ts\n   * import { parseFile } from 'web-csv-toolbox';\n   *\n   * const input = document.querySelector('input[type=\"file\"]');\n   * input.addEventListener('change', async (event) => {\n   *   const file = event.target.files[0];\n   *   await parseFile.toStream(file)\n   *     .pipeTo(\n   *       new WritableStream({\n   *         write(record) {\n   *           console.log(record);\n   *         },\n   *      }),\n   *   );\n   * });\n   * ```\n   */\n  export function toStream<Header extends ReadonlyArray<string>>(\n    file: File,\n    options?: ParseBinaryOptions<Header>,\n  ): ReadableStream<CSVRecord<Header>>;\n}\n\nObject.defineProperties(parseFile, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: parseBlob.toArray,\n  },\n  toStream: {\n    enumerable: true,\n    writable: false,\n    value: parseBlob.toStream,\n  },\n});\n"],"names":[],"mappings":";;AA+CO,SAAS,SAAA,CACd,MACA,OAAA,EAC0C;AAC1C,EAAA,OAAO,SAAA,CAAU,MAAM,OAAO,CAAA;AAChC;AAwDA,MAAA,CAAO,iBAAiB,SAAA,EAAW;AAAA,EACjC,OAAA,EAAS;AAAA,IACP,UAAA,EAAY,IAAA;AAAA,IACZ,QAAA,EAAU,KAAA;AAAA,IACV,OAAO,SAAA,CAAU;AAAA,GACnB;AAAA,EACA,QAAA,EAAU;AAAA,IACR,UAAA,EAAY,IAAA;AAAA,IACZ,QAAA,EAAU,KAAA;AAAA,IACV,OAAO,SAAA,CAAU;AAAA;AAErB,CAAC,CAAA;;;;"}

package/dist/parseRequest.d.ts

@@ -0,0 +1,120 @@
+import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
+/**
+ * Parse HTTP Request what contains CSV to records,
+ * ideal for server-side use cases.
+ *
+ * @remarks
+ * This function automatically treats request headers.
+ *
+ * - If `Content-Type` header is not set, it assumes `text/csv`.
+ * - If `Content-Type` header is not `text/csv`, it throws an error.
+ * - If `Content-Type` header has charset parameter, it uses it for decoding.
+ * - If `Content-Encoding` header is set, it decompresses the request.
+ * - Should there be any conflicting information between the header and the options, the option's value will take precedence.
+ *
+ * This function is particularly useful for server-side environments like Cloudflare Workers,
+ * Service Workers, or other edge computing platforms that use the Request API.
+ *
+ * @category Middle-level API
+ * @param request - The request object to parse
+ * @param options - Parsing options
+ * @returns Async iterable iterator of records.
+ *
+ * If you want array of records, use {@link parseRequest.toArray} function.
+ *
+ * @example Parsing CSV from Request (Cloudflare Workers)
+ *
+ * ```ts
+ * import { parseRequest } from 'web-csv-toolbox';
+ *
+ * export default {
+ *   async fetch(request: Request) {
+ *     if (request.method === 'POST' && request.headers.get('content-type')?.includes('text/csv')) {
+ *       for await (const record of parseRequest(request)) {
+ *         console.log(record);
+ *       }
+ *       return new Response('CSV processed', { status: 200 });
+ *     }
+ *     return new Response('Not Found', { status: 404 });
+ *   }
+ * };
+ * ```
+ *
+ * @example Parsing CSV from Request (Service Worker)
+ *
+ * ```ts
+ * import { parseRequest } from 'web-csv-toolbox';
+ *
+ * self.addEventListener('fetch', (event) => {
+ *   const request = event.request;
+ *   if (request.method === 'POST' && request.url.endsWith('/upload-csv')) {
+ *     event.respondWith(
+ *       (async () => {
+ *         const records = [];
+ *         for await (const record of parseRequest(request)) {
+ *           records.push(record);
+ *         }
+ *         return new Response(JSON.stringify(records), {
+ *           headers: { 'Content-Type': 'application/json' }
+ *         });
+ *       })()
+ *     );
+ *   }
+ * });
+ * ```
+ */
+export declare function parseRequest<Header extends ReadonlyArray<string>>(request: Request, options?: ParseBinaryOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
+export declare namespace parseRequest {
+    /**
+     * Parse CSV Request to array of records.
+     *
+     * @returns Array of records
+     *
+     * @example Parsing CSV Request
+     *
+     * ```ts
+     * import { parseRequest } from 'web-csv-toolbox';
+     *
+     * const request = new Request('https://example.com', {
+     *   method: 'POST',
+     *   headers: { 'Content-Type': 'text/csv' },
+     *   body: 'name,age\nAlice,42\nBob,69'
+     * });
+     *
+     * const records = await parseRequest.toArray(request);
+     * console.log(records);
+     * ```
+     */
+    function toArray<Header extends ReadonlyArray<string>>(request: Request, options?: ParseBinaryOptions<Header>): Promise<CSVRecord<Header>[]>;
+    /**
+     * Parse CSV Request to stream of records.
+     *
+     * @param request - Request to parse
+     * @returns Stream of records
+     *
+     * @example Parsing CSV Request
+     *
+     * ```ts
+     * import { parseRequest } from 'web-csv-toolbox';
+     *
+     * const request = new Request('https://example.com', {
+     *   method: 'POST',
+     *   headers: { 'Content-Type': 'text/csv' },
+     *   body: 'name,age\nAlice,42\nBob,69'
+     * });
+     *
+     * await parseRequest.toStream(request)
+     *   .pipeTo(
+     *     new WritableStream({
+     *       write(record) {
+     *         console.log(record);
+     *       },
+     *    }),
+     * );
+     * // Prints:
+     * // { name: 'Alice', age: '42' }
+     * // { name: 'Bob', age: '69' }
+     * ```
+     */
+    function toStream<Header extends ReadonlyArray<string>>(request: Request, options?: ParseBinaryOptions<Header>): ReadableStream<CSVRecord<Header>>;
+}