Refine types

Explicitly import `ReadableStream` to make TS understand `ReadableStream.from`

This change does not affect the code execution, but it makes the TS language server understand the `ReadableStream.from` static function. Without the explicit import, it is not possible using only JSDoc to merge the `ReadableStream` instance interface with the `ReadableStream` constructor because they share the same name.

Pin node types

Refactor `expandScientificNotation` to throw errors instead of using sentinel `null` value

Migrate from CLI options to explicit `tsconfig.json`

This change makes it easier to use an explicit `lib` configuration and types, which resolves type issues resulting from subtle mismatches between implied type imports (e.g., some files importing `ReadableStream` from TS's built-in Web API types and others importing from Node.js's `streams/web`).

Fix typechecking for `parsePathLike`

`PathLike` only includes Node.js's `Buffer` type, need to explicitly add the web API `TypedArray` (e.g., `Uint8Array`).

Bump Node.js version for dev

Check in package-lock

Explicitly assert that `byobRequest` and `view` are not null

Add TypeScript declaration file (`.d.ts`) generation

This is the cleanest way to make a JS library importable to a TS project. This approach is similar to Svelte's approach.

Note the dev dependency on TS is only used for `.d.ts` generation. The source code itself still does not use TS (or any dependencies other than Node.js) at all.

Add tests for `cancel`, `close`, and `abort`

Refactor to avoid undefined variables

Add tests for createFileStream

Block `cancel()` until `start()` is finished

If `cancel()` is called immediately after the stream is instantiated, it is possible that `start()` is not yet finished setting up the file handle before the `cancel()` logic is executed.

Refactor to unpack `options` into private properties

This change makes these properties consistent with other classes in this library. This change is also the simplest way to let the TypeScript language server understand that these properties are not null.

Refactor to simplify for language server

The TypeScript language server is not yet capable of understanding that the nullish coalescing assignment will make the property non-null, so it will show a type error. Another workaround would be to assert the property is non-null using a JSDoc equivalent to TypeScript's `!` but that is also not yet supported by JSDoc.

Delete outdated docs

Test UTF-16 BE decoding

`utf-16be` is not supported by Node.js's decoder in the `fs` module, but it is supported by the web standard Encoding API. So this is a good test to demonstrate the difference between the two.

Remove dependency on Node.js `createReadStream`

This change decouples the file reading from the character decoding, which enables use of the web standard Encoding API (`TextDecoderStream`) instead of Node.js's internal decoder. The web standard allows a broader set of encodings.

Bump Node.js version

Bump Node.js version

Add skip error strategy

Bump Node.js version

Add test for interval with 1 retry

Add `interval` option to `retry` strategy

Rename `options.value` to `options.placeholder`

Refactor extra arguments into options object

Rollback null-prototype to object prototype

Name collision is unlikely and enumeration may be useful. And it is easier for JSDoc to parse normal object initialization than `Object.create`.

Pin Node.js version

Add tests for ErrorStrategies

Freeze ErrorStrategies and use null prototype

This configuration is the most restrictive and fit for its intended purpose as a namespace only.

Add initial error strategies

Add JSDoc for benchmark utils

Add links to input and output CSVs

Refactor to simplify functions

Use package name for imports

Make test input paths relative to the file instead of command

Before, `npm test` only worked in the root directory. Now it can run in any directory.

Unlink file on keyboard interrupt

Reorder test name for easier skimming

Add 50MB benchmarks

Use unique pseudorandom seed on each generation

Use consistent name length to make it easier to compare outputs

Replace passthrough options with typeCastOnly

To replicate old behavior (passthrough as string), simply use `type: "string"`.

Assert non-nullable type instead of using nullish coalesce

There will be undefined `decimal` only if the input to `formatToParts` does not contain a decimal. But there will always be a decimal because the input is hardcoded.

The TS language server is not yet intelligent enough to assert it is non-nullable from the hardcoded input, so we need to pass the type hint.

Using nullish coalesce results in an uncovered branch which is impossible to test, so it should be removed.

Add additional tests for uncovered branches

Delete unnecessary token

Originally intended to match the remaining characters of the rest of the test name, but this is not needed since we only need to match the "large:" prefix.

Assert example 1.6 logs to console

Add 1MB benchmark

Silence console functions on stdout and instead assert they occurred

This approach makes the test runner output cleaner, and also tests the console calls occurred as expected.

Explicitly close file handle

Dismisses "Closing a FileHandle object on garbage collection" warnings in tests.

Add cleanup on abort

`close()` is NOT called if CSVWriter errors, only `abort()`. So need to call `close()` within `abort()` to finish cleanup.

Simplify ReadableStream constructor

Fix temp files not being deleted

The test runner will run code inside a test suite block even if the tests inside are skipped, which means the temp file was created but the cleanup `after()` call is skipped. Putting the creation within `before()` makes the temp file creation skipped it the tests are skipped.

Update prefix to match new project name

Add test for saving progress on uncaught error

Delete leftover flag from debugging

Add initial benchmarks

Update example to demonstrate more transformations

Fix regex to match examples

This change allows for the file name convention "wip_ex1_1.js" for in-progress examples.

Add "Abort a transformation" example

Improve type documentation

Fix broken test

Was previously passing by coincidence. Added an additional check to compare the actual rows vs. status rows.

Add npm script for running test coverage report

Add initial large CSV tests

Add test for changing elapsed status

Add tests for writing raw CSV strings

Add test for raising non-error rejection

Add test for handleHeaders error handling

Note that rows includes the header row

Add an example of using CSVWriter status

Add public status property to CSVWriter for tracking progress

Use consistent casing for types

Lowercase for all primitive types except Object and Array, TitleCase for all other types.

Add example to combine retry and graceful failure strategies

Add header row deletion test

Clarify handleHeaders intended usage

Setting it to an Array<any> is preferred for simple scenarios.

Add example to demonstrate passing a function to handleHeaders

Allow Array<any> and TransformationFunction as inputs to handle headers

This change simplifies the common tasks of (1) renaming headers (just pass the new header array) and (2) appending headers (pass a one-line TransformationFunction). Setting the option to a boolean is the same behavior as includeHeaders.

Passthrough encoding option for CSVReader

Add missing semicolon

Prepare for npm publish

Renumber and categorize examples

Headers make the examples easier to skim. Using minor numberings is also useful to later add more examples without having to renumber existing groupings each time.

Add graceful failure example

Refactor CSVNormalizer.fixExcelDate suite to vectors

Refactor CSVNormalizer.fixExcelBigInt suite to vectors

Refactor CSVNormalizer.fixExcelNumber suite to vectors

Run formatter

Refactor expandScientificNotation suite to vectors

Use CRLF line endings

Refactor toCamelCase suite to vectors

Add note about maxConcurrent for transformation function

Simplify with early returns

Rename to csvio

Use "concurrent" instead of "parallel" to avoid confusion with threads

Add maxConcurrent option

Tweak wording

Expose fix functions as static methods of CSVNormalizer

These functions may be useful to create custom normalizers.

Add JSDoc type to output rows

Refactor createCSVDenormalizationStream to CSVDenormalizer

Refactor createCSVNormalizationStream to CSVNormalizer

Make transform and flush private methods

Should've been private from the start to match pre-refactor.