Cut v0.1.11

Upgrade dependencies

Set `types` key for TS badge on npm registry

Although this key is redundant with `exports`, it is still required to have the "TS" badge on the npm registry.

Use staged publishing

Reference: https://docs.npmjs.com/staged-publishing/

Disable `package-manager-cache`

From `setup-node`'s `README`: "For workflows with elevated privileges or access to sensitive information, we recommend disabling automatic caching ... when caching is not required for secure operation."

Upgrade to TypeScript 6

Define `CSVWriterStatusInternal` type

This type captures the previously undocumented `start` property that is used internally only.

Add `aliases` to `CSVNormalizerHeader`

This feature is useful when input CSVs may have completely different column names for the same column, beyond standard normalization issues (e.g., i18n).

Cut v0.1.10

Upgrade dependencies

Add empty row test

Add additional AsyncGenerator tests

Loosen type definition to `AsyncIterable`

This change reflects the actual runtime check that is being performed (i.e., that `Symbol.asyncIterator` is implemented) and allows users to pass (runtime-valid) `async function*` transformation functions without any type errors.

Fix type to include undefined

Add explicit test for undefined

Cut v0.1.9

Upgrade dependencies

Add `.source` property for `FieldMap`

This property is useful when there is no other variable set to access the underlying row (e.g., `.toFieldMap` was called with a literal object).

Add `.from` static method

This method is intended to be the inverse of the `.toObject` method. It is useful to have such a method as a functional (i.e., non-mutating) alternative to `.toFieldMap` to transform rows in a transformation function.

Add explicit types

Update type to allow `Promise<ReadableStream<TransformationOutput>>` return value

Cut v0.1.8

Upgrade dependencies

Add test case for shorthand with literal names

Support ReadableStream from transformation

Fix bug where batch is cleared before transform function can use it

Demonstrate string shorthand

Implement `.delete()` and `.clear()`

Useful when a user wants to mostly duplicate an input row but make some minor tweaks. Not having the capability to remove rows leads to unwieldy workarounds.

Accept `string` as a shorthand for `{ name: string }`

It is common to set headers using all the default values, so it is useful to have a shorthand for this situation.

Fix regression where `null` and `undefined` are unable to be denormalized

Add links to tags

Don't pin versions in `devEngines`

This change is required to make the release CI work. The mismatched `npm` version in `devEngines` blocks the `npm i -g npm`, so it is impossible for `npm` to update itself.

Can revert this change only after Node.js version managers start using `devEngines` to automatically set `node` and `npm` versions.

Cut v0.1.7

Upgrade dependencies

Set default `name` property

This change makes the typing easier to follow.

Stringify all values passed through

This change makes `CSVDenormalizer` behave consistently with its current type definition and aligns expected behavior (if `CSVNormalizer` takes strings and gives native objects, then `CSVDenormalizer` should take native objects and give strings).

Add `CSVNormalizer.toFieldMap()`

Add `CSVNormalizer.toObject()` method

Delete unnecessary ternary

Improve JSDoc type import consistency

Delete unnecessary option

`type: 'string'` has been the default value since v0.1.3.

Pass through native type whenever possible

The stringification was legacy code from the original design of always JSON serializing each row between every stream. Since that serialization is no longer done, `CSVNormalizer` can just pass the native data type through. The downstream `CSVDenormalizer` should stringify all the data if the old behavior is desired.

Remove empty rows before the header row

Empty rows before the header are sometimes used for formatting purposes, and they should be removed from the data.

It is not possible to normalize an empty row before the headers are known, so empty rows that come before the header row are *always* removed, even if `passthroughEmptyRows` is `true`.

Make column matching case insensitive by default

Before: `datetime` and `dateTime` are considered different columns.

After: `datetime` and `dateTime` are considered the same column (last column prevails).

Note the output column name will still use the same casing passed in `CSVNormalizerHeader`.

`CSVNormalizer` already significantly modifies column names by normalizing to camelCase, so it is surprising the column matching is still case sensitive. It is likely that in the case a user wants `column A` and `columnA` to be the same column, that they'd also want `columna` to be the same as well.

Parse Unix timestamps

These three ways of representing dates as a number each have distinct magnitudes. I picked arbitrary cutoff dates to switch the logic under the assumption that values commonly seen in CSVs would not cross those cutoff dates.

Cut v0.1.6

Upgrade dependencies

Properly isolate and perform memory leak test

Previously the garbage collection tests were flaky, because `gc()` may or may not happen before the memory leak threshold is tested.

Now the test will properly block on garbage collection (observed to take about 15 seconds). Separating it into its own test also makes it easier to debug the `large:` test suites by reducing concerns in each test.

Use Trusted Publishing instead of long-lived npm token

See https://docs.npmjs.com/trusted-publishers

Allow passing an array to `placeholder`

This functionality is helpful to indicate different and more useful placeholders for each column.

It also allows setting a completely blank row (without any commas) on error, which may be desirable to make output CSV row counts match input CSV row counts without clutter.

Add manual type overrides

Add example of processing `.csv.gz` files

Delete unnecessary utility function

Add caching for dependencies

Clean up unused variables

Add git.ardis.lu mirror

Pin Node.js and npm versions in `devEngines`

`devEngines` is the standardized field for this purpose [0], with varying levels of tooling support. The duplicative and non-standard `.node-version` file will eventually be removed once tooling support for `devEngines` is more widespread.

[0] https://github.com/openjs-foundation/package-metadata-interoperability-collab-space

Broaden `value` type to `any`

Add note on long release notes

Add example for `stdin` and `stdout` usage

Rename `CSVNormalizerRow` to `CSVNormalizerField`

This type is not a row of data, it is a single field. So the name "row" never made sense.

Remove platform-specific data from test gzip file

This step is not required for real-world usage, but for testing purposes it is useful to share the same tests and test data across platforms.

Cut v0.1.5

Add `types:check` script mentioned in `CONTRIBUTING.md`

Upgrade dependencies

Add test case for raw strings passed to `TransformStream` CSVWriter

Add initial `TransformStream` CSVWriter implementation

This change enables users to create a `TransformStream` by doing `new CSVWriter()` instead of always creating an ultimate sink `WritableStream`. This behavior is useful when there is some transformation that must be performed on the CSV data before writing (e.g., compressing into a `.csv.gz` file using `CompressionStream`).

Delete unused import

Loosen `CSVNormalizerRow` type to match `CSVDenormalizer` usage

Add contribution checklist

Fix bug where it was not possible to read into an ArrayBuffer with offset

The code was originally correct because it was copied from the Streams specification [1], but turned incorrect after copying from Node.js's implementation [2], and now reverted back to the original correct implementation.

[1] https://streams.spec.whatwg.org/#example-rbs-pull
[2] https://github.com/nodejs/node/blob/134625d76139b4b3630d5baaf2efccae01ede564/lib/internal/fs/promises.js#L322

Delete unnecessary negative test

The row length check in `csvStreamEqualWritable` now covers the original testing edge case that necessitated the negative test. Now the test will correctly fail without requiring the negative test to trigger the failure.

Fix broken test

Fix `createProxy` type templates

Remove intermediate JSON serialization and `rawInput`/`rawOutput` options

Previously, each row was JSON serialized and deserialized on each `.pipeThrough`. The intent of this serialization was to normalize the data of each row, with an escape hatch in the `rawInput` and `rawOutput` options.

However, this approach is counterintuitive because most users would expect a CSV row to simply be an `Array<string>`, NOT a `string` that can be `JSON.parse`-ed into an `Array<string>`. Furthermore, this excessive serialization has a significant performance impact. Lastly, the `rawInput` and `rawOutput` options effectively made `CSVTransformer` an overly complex and difficult-to-use JSON parser on top of a CSV transformer.

So, simply removing the JSON serialization and directly enqueuing the actual object (i.e., the `Array<string>`) resolves all these issues with minimal impact to the user-facing API.

Fix words

Add npm script to create local dev packages

Add initial `TransformStream` CSVReader implementation

This change enables users to create a `TransformStream` by doing `new CSVReader()` instead of always creating an underlying source `ReadableStream`. This behavior is useful when there is some transformation that must be performed on the source file before parsing (e.g., decompressing a `.csv.gz` file using `DecompressionStream`).

Add tests for `instanceof` behavior

In preparation for possible future refactoring for these classes to return a `Proxy` object (this pattern is required to simulate dynamic superclasses, e.g., `CSVReader` returning either `ReadableStream` OR `TransformStream` depending on constructor argument). If such refactoring takes place, these tests will check that `Proxy` was implemented correctly and maintain backwards compatibility.

Add initial tests for memory leaks

Future tests should be dedicated for finding memory leaks only, but as an initial step it makes sense to add a simple sanity check to the large file tests.

Cut v0.1.4

Upgrade dependencies

Delete redundant BOM check

`TextDecoderStream` already handles it upstream, no need to check for it again.

Simplify implementation

Use consistent JSDoc typecasting formatting

Add initial documentation for `CSVNormalizer`

Re-export callback types

These types were initially missed because they are defined with the `callback` annotation and not `typedef`. For future completeness, search for `export type` in the generated declaration files.

Add `useLiteralNames` option to disable column name normalization

This behavior is useful to preserve data when an input CSV has multiple columns with the same normalized name. By default, `CSVNormalizer` will remove these duplicate columns (the data from the last column is used).

Note that columns with the same *literal* name are still removed even when `useLiteralNames` is `true`. If you need to preserve columns with the same literal name, use a lower-level transformation (e.g., `CSVTransformer`).

Add explicit test for `passthroughEmptyRows`

Re-export all types in `index.js`

Currently, the types are accessible internally in the library and within `index.js`, but NOT accessible from consumers importing from the `index.js` file. A re-export is required to make the types accessible to end-users.

Additionally, the JSDoc import will only work for types declared at the module scope, so `CSVWriterStatus` was moved to the outer scope.

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.