@types/papaparse

constructor

constructor(config: ParseConfig<any, undefined>);

method abort

abort: () => void;

method getCharIndex

getCharIndex: () => number;

method parse

parse: (input: string, baseIndex: number, ignoreLastRow: boolean) => any;

method pause

pause: () => void;

method resume

resume: () => void;

property comments

comments?: false | string | undefined;

• A string that indicates a comment (for example, "#" or "//"). When Papa encounters a line starting with this string, it will skip the line. false

property delimiter

delimiter?: string | ((input: string) => string) | undefined;

• The delimiting character. Leave blank to auto-detect from a list of most common delimiters, or any values passed in through delimitersToGuess. It can be a string or a function. If a string, it can be of any length (so multi-character delimiters are supported). If a function, it must accept the input as first parameter and it must return a string which will be used as delimiter. In both cases it cannot be found in Papa.BAD_DELIMITERS. // auto-detect

property delimitersToGuess

delimitersToGuess?: string[] | undefined;

• An array of delimiters to guess from if the delimiter option is not set. [',', '\t', '|', ';', Papa.RECORD_SEP, Papa.UNIT_SEP]

property dynamicTyping

dynamicTyping?:
    | boolean
    | { [headerName: string]: boolean; [columnNumber: number]: boolean }
    | ((field: string | number) => boolean)
    | undefined;

• If true, numeric and boolean data will be converted to their type instead of remaining strings. Numeric data must conform to the definition of a decimal literal. Numerical values greater than 2^53 or less than -2^53 will not be converted to numbers to preserve precision. European-formatted numbers must have commas and dots swapped. If also accepts an object or a function. If object it's values should be a boolean to indicate if dynamic typing should be applied for each column number (or header name if using headers). If it's a function, it should return a boolean value for each field number (or name if using headers) which will be passed as first argument. false

property escapeChar

escapeChar?: string | undefined;

• The character used to escape the quote character within a field. If not set, this option will default to the value of quoteChar, meaning that the default escaping of quote character within a quoted field is using the quote character two times. (e.g. "column with ""quotes"" in text") '"'

property fastMode

fastMode?: boolean | undefined;

• Fast mode speeds up parsing significantly for large inputs. However, it only works when the input has no quoted fields. Fast mode will automatically be enabled if no " characters appear in the input. You can force fast mode either way by setting it to true or false.

property header

header?: boolean | undefined;

• If true, the first row of parsed data will be interpreted as field names. An array of field names will be returned in meta, and each row of data will be an object of values keyed by field name instead of a simple array. Rows with a different number of fields from the header row will produce an error. Warning: Duplicate field names will overwrite values in previous fields having the same name. false

property newline

newline?: '\r' | '\n' | '\r\n' | undefined;

• The newline sequence. Leave blank to auto-detect. Must be one of \r, \n, or \r\n. // auto-detect

property preview

preview?: number | undefined;

• If > 0, only that many rows will be parsed.

property quoteChar

quoteChar?: string | undefined;

• The character used to quote fields. The quoting of all fields is not mandatory. Any field which is not quoted will correctly read. '"'

property skipEmptyLines

skipEmptyLines?: boolean | 'greedy' | undefined;

• If true, lines that are completely empty (those which evaluate to an empty string) will be skipped. If set to 'greedy', lines that don't have any content (those which have only whitespace after parsing) will also be skipped. false

method beforeFirstChunk

beforeFirstChunk: (chunk: string) => string | void;

• A function to execute before parsing the first chunk. Can be used with chunk or step streaming modes. The function receives as an argument the chunk about to be parsed, and it may return a modified chunk to parse. This is useful for stripping header lines (as long as the header fits in a single chunk).

method complete

complete: (results: ParseResult<T>, file: TInput) => void;

• The callback to execute when parsing is complete. It receives the parse results. If parsing a local file, the File is passed in, too. When streaming, parse results are not available in this callback.

method step

step: (results: ParseStepResult<T>, parser: Parser) => void;

• To stream the input, define a callback function. Streaming is necessary for large files which would otherwise crash the browser. You can call parser.abort() to abort parsing. And, except when using a Web Worker, you can call parser.pause() to pause it, and parser.resume() to resume.

method transform

transform: (value: string, field: string | number) => any;

• A function to apply on each value. The function receives the value as its first argument and the column number or header name when enabled as its second argument. The return value of the function will replace the value it received. The transform function is applied before dynamicTyping.

method transformHeader

transformHeader: (header: string, index: number) => string;

• A function to apply on each header. Requires header to be true. The function receives the header as its first argument and the index as second.

property code

code:
    | 'MissingQuotes'
    | 'UndetectableDelimiter'
    | 'TooFewFields'
    | 'TooManyFields'
    | 'InvalidQuotes';

• Standardized error code

property index

index?: number | undefined;

• Index within the row where error is

property message

message: string;

• Human-readable details

property row

row?: number | undefined;

• Row index of parsed data where error is

property type

type: 'Quotes' | 'Delimiter' | 'FieldMismatch';

• A generalization of the error

property aborted

aborted: boolean;

• Whether process was aborted

property cursor

cursor: number;

property delimiter

delimiter: string;

• Delimiter used

property fields

fields?: string[] | undefined;

• Array of field names

property linebreak

linebreak: string;

• Line break sequence used

property truncated

truncated: boolean;

• Whether preview consumed all input

property data

data: T[];

• an array of rows. If header is false, rows are arrays; otherwise they are objects of data keyed by the field name.

property errors

errors: ParseError[];

• an array of errors.

property meta

meta: ParseMeta;

• contains extra information about the parse, such as delimiter used, the newline sequence, whether the process was aborted, etc. Properties in this object are not guaranteed to exist in all situations.

property data

data: T;

• In the step callback, the data array will only contain one element.

property errors

errors: ParseError[];

• an array of errors.

property meta

meta: ParseMeta;

• contains extra information about the parse, such as delimiter used, the newline sequence, whether the process was aborted, etc. Properties in this object are not guaranteed to exist in all situations.

property worker

worker: true;

• Whether or not to use a worker thread. Using a worker will keep your page reactive, but may be slightly slower.

method complete

complete: (results: ParseResult<T>) => void;

• The callback to execute when parsing is complete. It receives the parse results. If parsing a local file, the File is passed in, too. When streaming, parse results are not available in this callback.

property columns

columns?: string[] | undefined;

• If data is an array of objects this option can be used to manually specify the keys (columns) you expect in the objects. If not set the keys of the first objects are used as column. undefined

property delimiter

delimiter?: string | undefined;

• The delimiting character. Multi-character delimiters are supported. It must not be found in Papa.BAD_DELIMITERS. ','

property escapeChar

escapeChar?: string | undefined;

• The character used to escape quoteChar inside field values. '"'

property escapeFormulae

escapeFormulae?: boolean | RegExp | undefined;

• If true, field values that begin with =, +, -, or @, will be prepended with a ` to defend against [injection attacks](https://www.contextis.com/en/blog/comma-separated-vulnerabilities), because Excel and LibreOffice will automatically parse such cells as formulae. false

property header

header?: boolean | undefined;

• If false, will omit the header row. If data is an array of arrays this option is ignored. If data is an array of objects the keys of the first object are the header row. If data is an object with the keys fields and data the fields are the header row. true

property newline

newline?: string | undefined;

• The character used to determine newline sequence. '\r\n'

property quoteChar

quoteChar?: string | undefined;

• The character used to quote fields. '"'

property quotes

quotes?:
    | boolean
    | boolean[]
    | ((value: any, columnIndex: number) => boolean)
    | undefined;

• If true, forces all fields to be enclosed in quotes. If an array of true/false values, specifies which fields should be force-quoted (first boolean is for the first column, second boolean for the second column, ...). A function that returns a boolean values can be used to determine the quotes value of a cell. This function accepts the cell value and column index as parameters. Note that this option is ignored for undefined, null and date-object values. The option escapeFormulae also takes precedence over this.

  false

property skipEmptyLines

skipEmptyLines?: boolean | 'greedy' | undefined;

• If true, lines that are completely empty (those which evaluate to an empty string) will be skipped. If set to 'greedy', lines that don't have any content (those which have only whitespace after parsing) will also be skipped. false

property data

data: T[];

property fields

fields: string[];