web-csv-toolbox 0.10.3-next-ee4125d4c2daeac2840037eddcc4335c766a489a → 0.10.3-pr317-874058b020bd8e180674e73a11c0abbd258327a5

package/dist/types/parse.d.ts

@@ -1,183 +0,0 @@
-import { CSVBinary, CSVRecord, CSVString, ParseBinaryOptions, ParseOptions } from './common/types.ts';
-
-/**
- * Parse CSV to records.
- *
- * {@link !String}, {@link !ReadableStream}<string | {@link !Uint8Array}> and {@link !Response} are supported.
- *
- *
- * @typeParam Header Header type like `['name', 'age']`.
- *
- * @param csv CSV string to parse.
- * @param options Parsing options for CSV string parsing.
- * @returns Async iterable iterator of records.
- *
- * If you want array of records, use {@link parse.toArray} function.
- * @category High-level API
- *
- * @remarks
- * {@link parseString}, {@link parseBinary}, {@link parseUint8ArrayStream},
- * {@link parseStringStream} and {@link parseResponse} are used internally.
- *
- * If you known the type of the CSV, it performs better to use them directly.
- *
- * | If you want to parse a...                    | Use...                        | Options...                 |
- * | -------------------------------------------- | ----------------------------- | -------------------------- |
- * | {@link !String}                              | {@link parseString}           | {@link ParseOptions}       |
- * | {@link !ReadableStream}<{@link !String}>     | {@link parseStringStream}     | {@link ParseOptions}       |
- * | {@link !Uint8Array} \| {@link !ArrayBuffer}  | {@link parseBinary}           | {@link ParseBinaryOptions} |
- * | {@link !ReadableStream}<{@link !Uint8Array}> | {@link parseUint8ArrayStream} | {@link ParseBinaryOptions} |
- * | {@link !Response}                            | {@link parseResponse}         | {@link ParseBinaryOptions} |
- *
- * @example Parsing CSV files from strings
- *
- * ```ts
- * import { parse } from 'web-csv-toolbox';
- *
- * const csv = `name,age
- * Alice,42
- * Bob,69`;
- *
- * for await (const record of parse(csv)) {
- *   console.log(record);
- * }
- * // Prints:
- * // { name: 'Alice', age: '42' }
- * // { name: 'Bob', age: '69' }
- * ```
- *
- * @example Parsing CSV files from streams
- *
- * ```ts
- * import { parse } from 'web-csv-toolbox';
- *
- * const csv = `name,age
- * Alice,42
- * Bob,69`;
- *
- * const stream = new ReadableStream({
- *   start(controller) {
- *     controller.enqueue(csv);
- *     controller.close();
- *   }
- * });
- *
- * for await (const record of parse(stream)) {
- *  console.log(record);
- * }
- * // Prints:
- * // { name: 'Alice', age: '42' }
- * // { name: 'Bob', age: '69' }
- * ```
- *
- *
- * @example Parsing CSV files with headers
- *
- * ```ts
- * import { parse } from 'web-csv-toolbox';
- *
- * // This CSV has no header.
- * const csv = `Alice,42
- * Bob,69`;
- *
- * for await (const record of parse(csv, { header: ['name', 'age'] })) {
- *  console.log(record);
- * }
- * // Prints:
- * // { name: 'Alice', age: '42' }
- * // { name: 'Bob', age: '69' }
- * ```
- *
- * @example Parsing CSV files with different delimiters characters
- *
- * ```ts
- * import { parse } from 'web-csv-toolbox';
- *
- * const csv = `name\tage
- * Alice\t42
- * Bob\t69`;
- *
- * for await (const record of parse(csv, { delimiter: '\t' })) {
- * console.log(record);
- * }
- * // Prints:
- * // { name: 'Alice', age: '42' }
- * // { name: 'Bob', age: '69' }
- * ```
- */
-export declare function parse<Header extends ReadonlyArray<string>>(csv: CSVString, options?: ParseOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
-/**
- * Parse CSV binary to records.
- *
- * @param csv CSV binary to parse.
- * @param options Parsing options for CSV binary parsing.
- *
- * @example Parsing CSV files from responses
- *
- * ```ts
- * import { parse } from 'web-csv-toolbox';
- *
- * // This CSV data is not gzipped and encoded in utf-8.
- * const response = await fetch('https://example.com/data.csv');
- *
- * for await (const record of parse(response)) {
- *   // ...
- * }
- * ```
- *
- * @example Parsing CSV files with options spcialized for binary
- *
- * ```ts
- * import { parse } from 'web-csv-toolbox';
- *
- * // This CSV data is gzipped and encoded in shift-jis and has BOM.
- * const response = await fetch('https://example.com/data.csv.gz');
- *
- * for await (const record of parse(response, {
- *   charset: 'shift-jis',
- *   ignoreBOM: true,
- *   decomposition: 'gzip',
- * })) {
- *   // ...
- * }
- * ```
- */
-export declare function parse<Header extends ReadonlyArray<string>>(csv: CSVBinary, options?: ParseBinaryOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
-export declare namespace parse {
-    /**
-     * Parse CSV string to array of records,
-     * ideal for smaller data sets.
-     *
-     * @example Parse a CSV as array of records
-     *
-     * ```ts
-     * import { parse } from 'web-csv-toolbox';
-     *
-     * const csv = `name,age
-     * Alice,42
-     * Bob,69`;
-     *
-     * const records = await parse.toArray(csv);
-     * console.log(records);
-     * // Prints:
-     * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]
-     * ```
-     */
-    function toArray<Header extends ReadonlyArray<string>>(csv: CSVString, options?: ParseOptions<Header>): Promise<CSVRecord<Header>[]>;
-    /**
-     * Parse CSV string to array of records,
-     * ideal for smaller data sets.
-     *
-     * @example Parse a CSV as array of records
-     *
-     * ```ts
-     * import { parse } from 'web-csv-toolbox';
-     *
-     * const response = await fetch('https://example.com/data.csv');
-     *
-     * const records = await parse.toArray(response);
-     * console.log(records);
-     * ```
-     */
-    function toArray<Header extends ReadonlyArray<string>>(csv: CSVBinary, options?: ParseBinaryOptions<Header>): Promise<CSVRecord<Header>[]>;
-}

package/dist/types/parseBinary.d.ts

@@ -1,114 +0,0 @@
-import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
-
-/**
- * Parse a binary from an {@link !Uint8Array}.
- *
- * @category Middle-level API
- *
- * @param bytes CSV bytes to parse.
- * @param options Parsing options
- * @returns Async iterable iterator of records.
- *
- * @example Parsing CSV binary
- *
- * ```ts
- * import { parseUint8Array } from 'web-csv-toolbox';
- *
- * const csv = Uint8Array.from([
- *   // ...
- * ]);
- *
- * for await (const record of parseUint8Array(csv)) {
- *   console.log(record);
- * }
- * ```
- */
-export declare function parseBinary<Header extends ReadonlyArray<string>>(bytes: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
-export declare namespace parseBinary {
-    /**
-     * Parse a binary from an {@link !Uint8Array} to an array of records.
-     *
-     * @param bytes CSV bytes to parse.
-     * @param options Parsing options
-     * @returns Array of records
-     *
-     * @example
-     * ```ts
-     * import { parseUint8Array } from 'web-csv-toolbox';
-     *
-     * const csv = Uint8Array.from([
-     *  // ...
-     * ]);
-     *
-     * const records = await parseUint8Array.toArray(csv);
-     * ```
-     */
-    function toArray<Header extends ReadonlyArray<string>>(bytes: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header>): Promise<CSVRecord<Header>[]>;
-    /**
-     * Parse a binary from an {@link !Uint8Array} to an array of records.
-     *
-     * @param bytes CSV bytes to parse.
-     * @param options Parsing options
-     * @returns Array of records
-     * @example
-     *
-     * ```ts
-     * import { parseUint8Array } from 'web-csv-toolbox';
-     *
-     * const csv = Uint8Array.from([
-     *  // ...
-     * ]);
-     *
-     * const records = parseUint8Array.toArraySync(csv);
-     * ```
-     */
-    function toArraySync<Header extends ReadonlyArray<string>>(bytes: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header>): CSVRecord<Header>[];
-    /**
-     * Parse a binary from an {@link !Uint8Array} to an iterable iterator of records.
-     *
-     * @param bytes CSV bytes to parse.
-     * @param options Parsing options
-     * @returns Async iterable iterator of records.
-     * @example
-     * ```ts
-     * import { parseUint8Array } from 'web-csv-toolbox';
-     *
-     * const csv = Uint8Array.from([
-     *  // ...
-     * ]);
-     *
-     * for (const record of parseUint8Array.toIterableIterator(csv)) {
-     *   console.log(record);
-     * }
-     * ```
-     */
-    function toIterableIterator<Header extends ReadonlyArray<string>>(bytes: Uint8Array, options?: ParseBinaryOptions<Header>): IterableIterator<CSVRecord<Header>>;
-    /**
-     * Parse a binary from an {@link !Uint8Array} to a stream of records.
-     *
-     * @param bytes CSV bytes to parse.
-     * @param options Parsing options
-     * @returns Stream of records.
-     *
-     * @example
-     *
-     * ```ts
-     * import { parseUint8Array } from 'web-csv-toolbox';
-     *
-     * const csv = Uint8Array.from([
-     *  // ...
-     * ]);
-     *
-     * const stream = parseUint8Array.toStream(csv);
-     *
-     * await stream.pipeTo(
-     *   new WritableStream({
-     *     write(record) {
-     *       console.log(record);
-     *     },
-     *   }),
-     * );
-     * ```
-     */
-    function toStream<Header extends ReadonlyArray<string>>(bytes: Uint8Array, options?: ParseBinaryOptions<Header>): ReadableStream<CSVRecord<Header>>;
-}

package/dist/types/parseBinaryToArraySync.d.ts

@@ -1,3 +0,0 @@
-import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
-
-export declare function parseBinaryToArraySync<Header extends ReadonlyArray<string>>(binary: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header>): CSVRecord<Header>[];

package/dist/types/parseBinaryToArraySync.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/parseBinaryToIterableIterator.d.ts

@@ -1,11 +0,0 @@
-import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
-
-/**
- * Parses the given binary data into an iterable iterator of CSV records.
- *
- * @param binary - The binary data to parse.
- * @param options - The parse options.
- * @returns An iterable iterator of CSV records.
- * @throws {ParseError} When an error occurs while parsing the CSV data.
- */
-export declare function parseBinaryToIterableIterator<Header extends ReadonlyArray<string>>(binary: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header>): IterableIterator<CSVRecord<Header>>;

package/dist/types/parseBinaryToStream.d.ts

@@ -1,3 +0,0 @@
-import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
-
-export declare function parseBinaryToStream<Header extends ReadonlyArray<string>>(binary: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header>): ReadableStream<CSVRecord<Header>>;

package/dist/types/parseResponse.d.ts

@@ -1,81 +0,0 @@
-import { CSVRecord, ParseOptions } from './common/types.ts';
-
-/**
- * Parse HTTP Response what contains CSV to records,
- * ideal for smaller data sets.
- *
- * @remarks
- * This function automatically treats response 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 response.
- * - Should there be any conflicting information between the header and the options, the option's value will take precedence.
- *
- * @category Middle-level API
- * @param response
- * @param options
- * @returns Async iterable iterator of records.
- *
- * If you want array of records, use {@link parseResponse.toArray} function.
- *
- * @example Parsing CSV Response
- *
- * ```ts
- * import { parseResponse } from 'web-csv-toolbox';
- *
- * const response = await fetch('https://example.com/data.csv');
- *
- * for await (const record of parseResponse(response)) {
- *   console.log(record);
- * }
- * ```
- */
-export declare function parseResponse<Header extends ReadonlyArray<string>>(response: Response, options?: ParseOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
-export declare namespace parseResponse {
-    /**
-     * Parse CSV Response to array of records.
-     *
-     * @returns Array of records
-     *
-     * @example Parsing CSV Response
-     *
-     * ```ts
-     * import { parseResponse } from 'web-csv-toolbox';
-     *
-     * const response = await fetch('https://example.com/data.csv');
-     *
-     * const records = await parseResponse.toArray(response);
-     * console.log(records);
-     * ```
-     */
-    function toArray<Header extends ReadonlyArray<string>>(response: Response, options?: ParseOptions<Header>): Promise<CSVRecord<Header>[]>;
-    /**
-     * Parse CSV Response to stream of records.
-     *
-     * @param response Response to parse
-     * @returns Stream of records
-     *
-     * @example Parsing CSV Response
-     *
-     * ```ts
-     * import { parseResponse } from 'web-csv-toolbox';
-     *
-     * const response = await fetch('https://example.com/data.csv');
-     *
-     * await parseResponse.toStream(response)
-     *   .pipeTo(
-     *     new WritableStream({
-     *       write(record) {
-     *         console.log(record);
-     *       },
-     *    }),
-     * );
-     * // Prints:
-     * // { name: 'Alice', age: '42' }
-     * // { name: 'Bob', age: '69' }
-     * ```
-     */
-    function toStream<Header extends ReadonlyArray<string>>(response: Response, options?: ParseOptions<Header>): ReadableStream<CSVRecord<Header>[]>;
-}

package/dist/types/parseResponseToStream.d.ts

@@ -1,3 +0,0 @@
-import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
-
-export declare function parseResponseToStream<Header extends ReadonlyArray<string>>(response: Response, options?: ParseBinaryOptions<Header>): ReadableStream<CSVRecord<Header>>;

package/dist/types/parseString.d.ts

@@ -1,121 +0,0 @@
-import { CSVRecord, ParseOptions } from './common/types.ts';
-
-/**
- * Parse CSV string to records.
- *
- * @category Middle-level API
- * @param csv CSV string to parse
- * @param options Parsing options. See {@link ParseOptions}.
- * @returns Async iterable iterator of records.
- *
- * If you want array of records, use {@link parseString.toArray} function.
- * @example Parsing CSV files from strings
- *
- * ```ts
- * import { parseString } from 'web-csv-toolbox';
- *
- * const csv = `name,age
- * Alice,42
- * Bob,69`;
- *
- * for await (const record of parseString(csv)) {
- *   console.log(record);
- * }
- * // Prints:
- * // { name: 'Alice', age: '42' }
- * // { name: 'Bob', age: '69' }
- * ```
- */
-export declare function parseString<Header extends ReadonlyArray<string>>(csv: string, options?: ParseOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
-export declare namespace parseString {
-    /**
-     * Parse CSV string to records.
-     *
-     * @returns Array of records
-     *
-     * @example
-     * ```ts
-     * import { parseString } from 'web-csv-toolbox';
-     *
-     * const csv = `name,age
-     * Alice,42
-     * Bob,69`;
-     *
-     * const records = await parseString.toArray(csv);
-     * console.log(records);
-     * // Prints:
-     * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]
-     * ```
-     */
-    function toArray<Header extends ReadonlyArray<string>>(csv: string, options?: ParseOptions<Header>): Promise<CSVRecord<Header>[]>;
-    /**
-     * Parse CSV string to records.
-     *
-     * @returns Array of records
-     *
-     * @example
-     *
-     * ```ts
-     * import { parseString } from 'web-csv-toolbox';
-     *
-     * const csv = `name,age
-     * Alice,42
-     * Bob,69`;
-     *
-     * const records = parseString.toArraySync(csv);
-     * console.log(records);
-     * // Prints:
-     * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]
-     * ```
-     */
-    function toArraySync<Header extends ReadonlyArray<string>>(csv: string, options?: ParseOptions<Header>): CSVRecord<Header>[];
-    /**
-     * Parse CSV string to records.
-     *
-     * @returns Async iterable iterator of records
-     *
-     * @example
-     * ```ts
-     * import { parseString } from 'web-csv-toolbox';
-     *
-     * const csv = `name,age
-     * Alice,42
-     * Bob,69`;
-     *
-     * for (const record of parseString.toIterableIterator(csv)) {
-     *   console.log(record);
-     * }
-     * // Prints:
-     * // { name: 'Alice', age: '42' }
-     * // { name: 'Bob', age: '69' }
-     * ```
-     */
-    function toIterableIterator<Header extends ReadonlyArray<string>>(csv: string, options?: ParseOptions<Header>): IterableIterator<CSVRecord<Header>>;
-    /**
-     * Parse CSV string to records.
-     *
-     * @returns Readable stream of records
-     *
-     * @example
-     * ```ts
-     * import { parseString } from 'web-csv-toolbox';
-     *
-     * const csv = `name,age
-     * Alice,42
-     * Bob,69`;
-     *
-     * await parseString.toStream(csv)
-     *   .pipeTo(
-     *      new WritableStream({
-     *        write(record) {
-     *          console.log(record);
-     *        },
-     *      }),
-     *   );
-     * // Prints:
-     * // { name: 'Alice', age: '42' }
-     * // { name: 'Bob', age: '69' }
-     * ```
-     */
-    function toStream<Header extends ReadonlyArray<string>>(csv: string, options?: ParseOptions<Header>): ReadableStream<CSVRecord<Header>>;
-}

package/dist/types/parseStringStream.d.ts

@@ -1,99 +0,0 @@
-import { CSVRecord, ParseOptions } from './common/types.ts';
-
-/**
- * Parse CSV string stream to records.
- *
- * @category Middle-level API
- * @param stream CSV string stream to parse
- * @param options Parsing options.
- * @returns Async iterable iterator of records.
- *
- * If you want array of records, use {@link parseStringStream.toArray} function.
- *
- * @example Parsing CSV files from strings
- *
- * ```ts
- * import { parseStringStream } from 'web-csv-toolbox';
- *
- * const csv = `name,age
- * Alice,42
- * Bob,69`;
- *
- * const stream = new ReadableStream({
- *  start(controller) {
- *     controller.enqueue(csv);
- *     controller.close();
- *   },
- * });
- *
- * for await (const record of parseStringStream(csv)) {
- *   console.log(record);
- * }
- * // Prints:
- * // { name: 'Alice', age: '42' }
- * // { name: 'Bob', age: '69' }
- * ```
- */
-export declare function parseStringStream<Header extends ReadonlyArray<string>>(stream: ReadableStream<string>, options?: ParseOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
-export declare namespace parseStringStream {
-    /**
-     * Parse CSV string stream to records.
-     *
-     * @returns Array of records
-     *
-     * @example
-     *
-     * ```ts
-     * import { parseStringStream } from 'web-csv-toolbox';
-     *
-     * const csv = `name,age
-     * Alice,42
-     * Bob,69`;
-     *
-     * const stream = new ReadableStream({
-     *   start(controller) {
-     *     controller.enqueue(csv);
-     *     controller.close();
-     *   },
-     * });
-     *
-     * const records = await parseStringStream.toArray(stream);
-     * console.log(records);
-     * // Prints:
-     * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]
-     * ```
-     */
-    function toArray<Header extends ReadonlyArray<string>>(stream: ReadableStream<string>, options?: ParseOptions<Header>): Promise<CSVRecord<Header>[]>;
-    /**
-     * Parse CSV string stream to records.
-     *
-     * @returns Array of records
-     *
-     * @example
-     *
-     * ```ts
-     * import { parseStringStream } from 'web-csv-toolbox';
-     *
-     * const csv = `name,age
-     * Alice,42
-     * Bob,69`;
-     *
-     * const stream = new ReadableStream({
-     *   start(controller) {
-     *     controller.enqueue(csv);
-     *     controller.close();
-     *   },
-     * });
-     *
-     * await parseStringStream.toStream(stream)
-     *   .pipeTo(
-     *     new WritableStream({
-     *       write(record) {
-     *       console.log(record);
-     *     },
-     *   }),
-     * );
-     * ```
-     */
-    function toStream<Header extends ReadonlyArray<string>>(stream: ReadableStream<string>, options?: ParseOptions<Header>): ReadableStream<CSVRecord<Header>>;
-}

package/dist/types/parseStringStreamToStream.d.ts

@@ -1,3 +0,0 @@
-import { CSVRecord, ParseOptions } from './common/types.ts';
-
-export declare function parseStringStreamToStream<Header extends ReadonlyArray<string>>(stream: ReadableStream<string>, options?: ParseOptions<Header>): ReadableStream<CSVRecord<Header>>;

package/dist/types/parseStringToArraySync.d.ts

@@ -1,3 +0,0 @@
-import { CSVRecord, ParseOptions } from './common/types.ts';
-
-export declare function parseStringToArraySync<Header extends ReadonlyArray<string>>(csv: string, options?: ParseOptions<Header>): CSVRecord<Header>[];

package/dist/types/parseStringToArraySyncWASM.d.ts

@@ -1,38 +0,0 @@
-import { CSVRecord, CommonOptions } from './common/types.ts';
-
-/**
- * Parse CSV string to record of arrays.
- *
- * @param csv CSV string
- * @param options Parse options
- * @returns Record of arrays
- *
- * @remarks
- * This function uses WebAssembly to parse CSV string.
- * Before calling this function, you must call {@link loadWASM} function.
- *
- * This function only supports UTF-8 string.
- * If you pass a string that is not UTF-8, like UTF-16, it throws an error.
- * This function only supports double quote as quotation.
- * So, `options.quotation` must be `"` (double quote). Otherwise, it throws an error.
- *
- * And this function only supports single character as delimiter.
- * So, `options.delimiter` must be a single character. Otherwise, it throws an error.
- *
- * @example
- *
- * ```ts
- * import { loadWASM, parseStringWASM } from "web-csv-toolbox";
- *
- * await loadWASM();
- *
- * const csv = "a,b,c\n1,2,3";
- *
- * const result = parseStringToArraySyncWASM(csv);
- * console.log(result);
- * // Prints:
- * // [{ a: "1", b: "2", c: "3" }]
- * ```
- * @beta
- */
-export declare function parseStringToArraySyncWASM<Header extends readonly string[]>(csv: string, options?: CommonOptions): CSVRecord<Header>[];

package/dist/types/parseStringToIterableIterator.d.ts

@@ -1,3 +0,0 @@
-import { CSVRecord, ParseOptions } from './common/types.ts';
-
-export declare function parseStringToIterableIterator<Header extends ReadonlyArray<string>>(csv: string, options?: ParseOptions<Header>): IterableIterator<CSVRecord<Header>>;

package/dist/types/parseStringToStream.d.ts

@@ -1,3 +0,0 @@
-import { CSVRecord, ParseOptions } from './common/types.ts';
-
-export declare function parseStringToStream<Header extends ReadonlyArray<string>>(csv: string, options?: ParseOptions<Header>): ReadableStream<CSVRecord<Header>>;