μDSV - A Fast CSV Parser

Common errors

• Refused to evaluate a string as JavaScript because 'unsafe-eval' is not an allowed source in the following Content Security Policy directive: "script-src 'self'".

  cause Your browser environment has a strict Content Security Policy that prohibits the use of `eval` or `new Function()`, which uDSV's typed parsing methods depend on.
  fix Either adjust your CSP to allow `unsafe-eval` (if your security policy permits), or switch to using `parser.stringArrs()` to get raw string outputs and implement manual type conversion logic in your application.

• CSV parsing error: Unexpected character after quoted field (e.g., '"value"extra' instead of '"value",next').

  cause This often occurs when a character immediately follows a closing quote without a delimiter, violating RFC 4180 rules. Or, line breaks within a quoted field do not match the row delimiter.
  fix Verify that your CSV strictly adheres to RFC 4180. Ensure no extraneous characters exist after quoted fields before a delimiter or newline. Also, confirm that all line breaks inside quoted fields are identical to the file's primary row delimiter.

Warnings

• gotcha Line breaks within quoted CSV values must exactly match the row separator used throughout the rest of the CSV. For example, if rows are separated by `\n`, quoted fields containing line breaks must also use `\n`, not `\r\n` or `\r`.
  Fix: Ensure consistent line ending usage across the entire CSV file, particularly within quoted fields, to match the chosen row delimiter. Most tools can standardize line endings.
• gotcha uDSV's advanced `typed*()` methods (e.g., `typedObjs`, `typedArrs`) rely on dynamically-generated functions via `new Function()`. Environments with strict Content Security Policy (CSP) headers that disallow `unsafe-eval` will prevent these methods from functioning.
  Fix: If `unsafe-eval` cannot be enabled in your CSP, you must manually perform type conversions on the raw string outputs provided by `parser.stringArrs()` or similar methods.

Install

• npm install udsv npm
• yarn add udsv yarn
• pnpm add udsv pnpm

Imports

• inferSchema
  wrong:

  const { inferSchema } = require('udsv');

  correct:

  import { inferSchema } from 'udsv';

  Used to automatically detect the CSV structure from a string sample. The library is ESM-first.
• initParser
  wrong:

  const { initParser } = require('udsv');

  correct:

  import { initParser } from 'udsv';

  Initializes a parser instance with a given schema, which can be inferred or custom.
• parser.stringArrs / parser.typedObjs

  const parser = initParser(schema);
  const stringArrays = parser.stringArrs(csvStr);
  const typedObjects = parser.typedObjs(stringArrays);

  These are methods of the parser instance, used to obtain raw string arrays or schema-typed objects after parsing.

Quickstart

This quickstart demonstrates how to infer a schema from a CSV string, initialize the parser, and then parse the data into both raw string arrays and schema-typed objects for easier manipulation.

import { inferSchema, initParser } from 'udsv';

const csvString = 'name,age,city\nAlice,30,New York\nBob,24,London\nCharlie,35,"Paris, France"';

// 1. Infer schema from the CSV string
const schema = inferSchema(csvString);
console.log('Inferred Schema:', schema);

// 2. Initialize the parser with the schema
const parser = initParser(schema);

// 3. Parse to arrays of strings (raw values)
const stringArrays = parser.stringArrs(csvString);
console.log('Parsed as String Arrays:', stringArrays);
/* Output: [
  ['name', 'age', 'city'],
  ['Alice', '30', 'New York'],
  ['Bob', '24', 'London'],
  ['Charlie', '35', 'Paris, France']
] */

// 4. Parse to typed objects (using the inferred schema's types)
const typedObjects = parser.typedObjs(stringArrays);
console.log('Parsed as Typed Objects:', typedObjects);
/* Output: [
  { name: 'Alice', age: 30, city: 'New York' },
  { name: 'Bob', age: 24, city: 'London' },
  { name: 'Charlie', age: 35, city: 'Paris, France' }
] */