Cut v0.1.3

Upgrade dependencies

Fix bug where `defaultValue` was not set if row is uneven

Add explicit test for sparse CSV

Delete debugging flag

Add an example for `CSVTransformer` interaction with `CSVNormalizer`

Simplify type annotation

Ignore `handleHeaders` if the row has been normalized

This behavior is desirable when `CSVTransformer` interacts with `CSVNormalizer` or any other transformation which converts the row from `Array<string>` into `Array<Object>`, because it avoids the need to pass `handleHeaders: true` to `CSVTransformer` (which is counterintuitive). It is more accurate to say the header row has been deleted by the transformation and must by re-inserted into the write stream later.

The loosening of the type checking is not a breaking change. Since the row is passed directly to `JSON.parse()`, the fields could have always been type `Object` instead of `string`.

Fall back on `name` if `displayName` is undefined

This behavior is useful when passing rows to `CSVDenormalizer` after a transformation *other* than `CSVNormalizer` (which automatically creates `displayName`).

Set default normalization type to `'string'`

This behavior is helpful to perform minimal normalization tasks but otherwise preserve the default CSV transformation behavior (i.e., have all input values be a string).

This is not a breaking change. Previously, `type` would also default to `'string'` after logging a warning in console.

Fix bug where extra normalization headers were not dropped

This bug was not caught due to a separate bug in the test logic, which is also fixed in this commit.

Add explicit test to remove extra headers

Sort keys to match default order in 5.9

Reference: https://devblogs.microsoft.com/typescript/announcing-typescript-5-9-beta/

Delete unnecessary constructor annotation

This tag has no impact on the generated `.d.ts` file so it can be removed.

Cut v0.1.2

Upgrade dependencies

Support ArrayLike outputs

Could be useful for chained transformations using DOM APIs, e.g. passing through the NodeList object.

Improve internal type documentation

Increase `highWaterMark` for `CSVWriter`'s queuing strategy

This change improves the 100MB Write benchmark from ~9s to ~7s.

Bumping `highWaterMark` to >1 also changes the stream's interaction with `AbortController`, so now the chunk processed during an abort is included in the write.

I believe this behavior has to do with the task queue order of the callback for the `AbortSignal`'s `abort` event - so now with multiple chunks in the queue, the last chunk is written before the `abort` event is processed. I was unable to force this writing code to occur after the `abort` event in a deterministic way.

This situation is a rare edge case so letting it through.

Simplify and harden tick indicator

Relying on physical timing is flaky (e.g., it will fail if executing on a slow machine).  Sending a simple `tick` increment into the task queue is more reliable.

Tweak wording

Add test to remove empty columns

Handle whitespace strings

Support path of type `SharedArrayBuffer`

Increase default chunk size from 1 KiB to 64 KiB

Benchmarks showed improvements or no change across all tests. Notably, 100MB Read improved from ~13s to ~3s.

The magic value of 64 KiB was selected based on Node.js's default of 16 KiB in similar code [1] and manually testing some multiples over that (Node.js tends to be conservative).

[1] https://github.com/nodejs/node/blob/f69f90d97a30cf9a5f7cbe0260e487ae4d457ed5/lib/internal/fs/promises.js#L317

Remove `scripts` and `devDependencies` from packed `package.json`

These keys are used for development purposes only, so it is wasting bandwidth to ship them with the final package.

Move prepack script to a JS file

To facilitate future more complex transformations that would be easier to manage in a code file.

Use consistent casing

Upgrade dependencies

Add code repository mirrors

Clarify type to allow raw `ArrayBuffer`, not just `TypedArray`

Upgrade dependencies

Simplify release notes to be auto generated

Reasons in favor of minimal release notes: (1) Releases is a GitHub functionality, it's better not to invest too much time into vendor-specific configurations. (2) There is no binary associated with this library so Releases has reduced significance. (3) Meaningful release notes are still contained in git tag annotations, which can be carried across hosts.

One downside is losing meaningful messages in email notifications if people subscribe to follow releases on GitHub.

Cut v0.1.1

Release and publish on new version tags

Add keywords

Update for new scoped package name

Publish as scoped package

Add prepack script

Upgrade dependencies

Normalize repository value

Even though the shorthand is valid,  `npm publish` will show a warning every time about running `npm pkg fix` unless it is normalized.

Use `outDir` instead of `outFile`

`outFile` is not compatible with ES6 modules.

Tweak types

Upgrade dependencies

Strictly count the number of batches

Update `maxBatchSize` behavior to match type documentation

**Any** value should start batching, instead of any value > 1.

Add overloads for raw and batch transformation variants based on options provided to the constructor

If `rawInput` is `true`, then `TransformationFunctionRaw` is required.

If `maxBatchSize` is set to any number (including `1`), then `TransformationFunctionBatch` is required.

Otherwise, `TransformationFunction` is required.

This change resolves all remaining type problems in `core.test.js`.

Refactor `DECIMAL_SEPARATOR` to a function

This change enables easier testing and also allows future improvements for dynamically changing the locale during runtime.

Refine types

Refactor to pass options through to private fields

This change makes the code consistent with previous refactoring on the core code, and also prevents unexpected behavior from mutating the options object after instantiation.

Fix docs

The retry is not necessarily immediate if `interval` is specified in options.

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.