input->text, parseString -> parseText

Author: severo

src/index.ts

@@ -1,3 +1,3 @@
-export { parseString } from './string'
+export { parseText } from './text'
 export { parseUrl } from './url'
 export { testEmptyLine } from './utils'

src/options/delimiter.ts

@@ -20,13 +20,13 @@ export function validateDelimiter(delimiter?: string): undefined | string {
 
 /**
  * Guess the delimiter
- * @param input The input string
+ * @param text The string
  * @param newline The newline character
  * @param comments The comment character or boolean to indicate comments
  * @param delimitersToGuess The list of delimiters to guess from
  * @returns An object indicating whether guessing was successful and the best delimiter found
  */
-export function guessDelimiter(input: string, newline?: Newline, comments?: boolean | string, delimitersToGuess?: string[]) {
+export function guessDelimiter(text: string, newline?: Newline, comments?: boolean | string, delimitersToGuess?: string[]) {
   let bestDelimiter, bestDelta, maxFieldCount
 
   delimitersToGuess = delimitersToGuess || [',', '\t', '|', ';', RECORD_SEP, UNIT_SEP]
@@ -40,7 +40,7 @@ export function guessDelimiter(input: string, newline?: Newline, comments?: bool
     let j = 0
     const previewLines = 10
 
-    for (const { row } of parse(input, {
+    for (const { row } of parse(text, {
       delimiter,
       newline,
       comments,

src/options/newline.ts

@@ -14,19 +14,19 @@ export function validateNewline(newline?: Newline): Newline | undefined {
 
 /**
  * Guess the line endings
- * @param input The input string
+ * @param text The string
  * @param quoteChar The quote character
  * @returns The line ending character
  */
-export function guessLineEndings(input: string, quoteChar: string): Newline {
-  input = input.substring(0, 1024 * 1024) // max length 1 MB
+export function guessLineEndings(text: string, quoteChar: string): Newline {
+  text = text.substring(0, 1024 * 1024) // max length 1 MB
   // Replace all the text inside quotes
   const re = new RegExp(escapeRegExp(quoteChar) + '([^]*?)' + escapeRegExp(quoteChar), 'gm')
-  input = input.replace(re, '')
+  text = text.replace(re, '')
 
-  const r = input.split('\r')
+  const r = text.split('\r')
 
-  const n = input.split('\n')
+  const n = text.split('\n')
 
   /* v8 ignore if -- @preserve */
   if (!(0 in r && 0 in n)) {

src/options/parseOptions.ts

@@ -27,26 +27,26 @@ export interface DelimiterError {
  * @param parseOptions.escapeChar The escape character used in the CSV data. Defaults to the quote character.
  * @param parseOptions.comments The comment character or boolean to indicate comments.
  * @param params The parameters for validation and guessing.
- * @param params.input The input string to use for guessing.
+ * @param params.text The string to use for guessing.
  * @param params.delimitersToGuess The list of delimiters to guess from.
  * @returns The validated and guessed parsing options, and the delimiter error (if any).
  */
-export function validateAndGuessParseOptions(parseOptions: ParseOptions, { input, delimitersToGuess}: {
-  input: string
+export function validateAndGuessParseOptions(parseOptions: ParseOptions, { text, delimitersToGuess}: {
+  text: string
   delimitersToGuess?: string[]
 }): {
   parseOptions: ParseOptions
   error?: DelimiterError
 } {
   const quoteChar = validateQuoteChar(parseOptions.quoteChar)
   const escapeChar = validateEscapeChar(parseOptions.escapeChar) ?? quoteChar
-  const newline = validateNewline(parseOptions.newline) ?? guessLineEndings(input, quoteChar)
+  const newline = validateNewline(parseOptions.newline) ?? guessLineEndings(text, quoteChar)
   const comments = parseOptions.comments
 
   let error: DelimiterError | undefined
   let delimiter = validateDelimiter(parseOptions.delimiter)
   if (!delimiter) {
-    const delimGuess = guessDelimiter(input, newline, comments, delimitersToGuess)
+    const delimGuess = guessDelimiter(text, newline, comments, delimitersToGuess)
     if (delimGuess.successful)
       delimiter = delimGuess.bestDelimiter
     else {

src/parser.ts

@@ -4,20 +4,20 @@ import type { ParseError, ParseResult } from './types'
 import { escapeRegExp } from './utils'
 
 /**
- * Parses the input string with the given options
- * @param input The input string to parse
+ * Parses the text with the given options
+ * @param text The string to parse
  * @param options The options for parsing
  * @param options.delimiter The delimiter used in the CSV data. Defaults to ','.
  * @param options.newline The newline used in the CSV data. Defaults to '\n'.
  * @param options.quoteChar The quote character used in the CSV data. Defaults to '"'.
  * @param options.escapeChar The escape character used in the CSV data. Defaults to the quote character.
  * @param options.comments The comment character or boolean to indicate comments. Defaults to false (don't strip comments).
  * @param options.ignoreLastRow Whether to ignore the last row. Defaults to false.
- * @param options.stripBOM Whether to strip the BOM character at the start of the input. Defaults to true.
+ * @param options.stripBOM Whether to strip the BOM character at the start of the text. Defaults to true.
  * @yields The parse results, one row at a time
  * @returns A generator yielding parse results
  */
-export function* parse(input: string, options: ParseOptions & {
+export function* parse(text: string, options: ParseOptions & {
   ignoreLastRow?: boolean
   stripBOM?: boolean
 } = {}): Generator<ParseResult, void, unknown> {
@@ -33,7 +33,7 @@ export function* parse(input: string, options: ParseOptions & {
 
   // We don't need to compute some of these every time parse() is called,
   // but having them in a more local scope seems to perform better
-  const inputLen = input.length,
+  const textLen = text.length,
     delimLen = delimiter.length,
     newlineLen = newline.length,
     commentsLen = comments === false ? 0 : comments.length
@@ -45,19 +45,19 @@ export function* parse(input: string, options: ParseOptions & {
   let lastCursor = 0
   let offset = 0 // Byte offset
 
-  if (stripBOM && input.charCodeAt(0) === 0xfeff) {
+  if (stripBOM && text.charCodeAt(0) === 0xfeff) {
     cursor = 1
   }
 
-  let nextDelim = input.indexOf(delimiter, cursor)
-  let nextNewline = input.indexOf(newline, cursor)
+  let nextDelim = text.indexOf(delimiter, cursor)
+  let nextNewline = text.indexOf(newline, cursor)
   const quoteCharRegex = new RegExp(escapeRegExp(escapeChar) + escapeRegExp(quoteChar), 'g')
-  let quoteSearch = input.indexOf(quoteChar, cursor)
+  let quoteSearch = text.indexOf(quoteChar, cursor)
 
   // Parser loop
   for (;;) {
     // Field has opening quote
-    if (input[cursor] === quoteChar) {
+    if (text[cursor] === quoteChar) {
       // Start our search for the closing quote where the cursor is
       quoteSearch = cursor
 
@@ -66,7 +66,7 @@ export function* parse(input: string, options: ParseOptions & {
 
       for (;;) {
         // Find closing quote
-        quoteSearch = input.indexOf(quoteChar, quoteSearch + 1)
+        quoteSearch = text.indexOf(quoteChar, quoteSearch + 1)
 
         // No other quotes are found - no other delimiters
         if (quoteSearch === -1) {
@@ -86,8 +86,8 @@ export function* parse(input: string, options: ParseOptions & {
         }
 
         // Closing quote at EOF
-        if (quoteSearch === inputLen - 1) {
-          const value = input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar)
+        if (quoteSearch === textLen - 1) {
+          const value = text.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar)
           const last = finish(value)
           if (last) {
             yield last
@@ -97,53 +97,53 @@ export function* parse(input: string, options: ParseOptions & {
 
         // If this quote is escaped, it's part of the data; skip it
         // If the quote character is the escape character, then check if the next character is the escape character
-        if (quoteChar === escapeChar && input[quoteSearch + 1] === escapeChar) {
+        if (quoteChar === escapeChar && text[quoteSearch + 1] === escapeChar) {
           quoteSearch++
           continue
         }
 
         // If the quote character is not the escape character, then check if the previous character was the escape character
-        if (quoteChar !== escapeChar && quoteSearch !== 0 && input[quoteSearch - 1] === escapeChar) {
+        if (quoteChar !== escapeChar && quoteSearch !== 0 && text[quoteSearch - 1] === escapeChar) {
           continue
         }
 
         if (nextDelim !== -1 && nextDelim < (quoteSearch + 1)) {
-          nextDelim = input.indexOf(delimiter, (quoteSearch + 1))
+          nextDelim = text.indexOf(delimiter, (quoteSearch + 1))
         }
         if (nextNewline !== -1 && nextNewline < (quoteSearch + 1)) {
-          nextNewline = input.indexOf(newline, (quoteSearch + 1))
+          nextNewline = text.indexOf(newline, (quoteSearch + 1))
         }
         // Check up to nextDelim or nextNewline, whichever is closest
         const checkUpTo = nextNewline === -1 ? nextDelim : Math.min(nextDelim, nextNewline)
-        const spacesBetweenQuoteAndDelimiter = extraSpaces({ index: checkUpTo, input, quoteSearch })
+        const spacesBetweenQuoteAndDelimiter = extraSpaces({ index: checkUpTo, text, quoteSearch })
 
         // Closing quote followed by delimiter or 'unnecessary spaces + delimiter'
         const startA = quoteSearch + 1 + spacesBetweenQuoteAndDelimiter
         const endA = startA + delimLen
-        if (input.substring(startA, endA) === delimiter) {
-          row.push(input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar))
+        if (text.substring(startA, endA) === delimiter) {
+          row.push(text.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar))
           cursor = endA
 
           // If char after following delimiter is not quoteChar, we find next quote char position
-          if (input[endA] !== quoteChar) {
-            quoteSearch = input.indexOf(quoteChar, cursor)
+          if (text[endA] !== quoteChar) {
+            quoteSearch = text.indexOf(quoteChar, cursor)
           }
-          nextDelim = input.indexOf(delimiter, cursor)
-          nextNewline = input.indexOf(newline, cursor)
+          nextDelim = text.indexOf(delimiter, cursor)
+          nextNewline = text.indexOf(newline, cursor)
           break
         }
 
-        const spacesBetweenQuoteAndNewLine = extraSpaces({ index: nextNewline, input, quoteSearch })
+        const spacesBetweenQuoteAndNewLine = extraSpaces({ index: nextNewline, text, quoteSearch })
 
         // Closing quote followed by newline or 'unnecessary spaces + newLine'
         const startB = quoteSearch + 1 + spacesBetweenQuoteAndNewLine
         const endB = startB + newlineLen
-        if (input.substring(startB, endB) === newline) {
-          row.push(input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar))
+        if (text.substring(startB, endB) === newline) {
+          row.push(text.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar))
           cursor = endB
-          nextNewline = input.indexOf(newline, cursor)
-          nextDelim = input.indexOf(delimiter, cursor) // because we may have skipped the nextDelim in the quoted field
-          quoteSearch = input.indexOf(quoteChar, cursor) // we search for first quote in next line
+          nextNewline = text.indexOf(newline, cursor)
+          nextDelim = text.indexOf(delimiter, cursor) // because we may have skipped the nextDelim in the quoted field
+          quoteSearch = text.indexOf(quoteChar, cursor) // we search for first quote in next line
 
           /** Yields the row and resets row & errors. */
           yield getResult()
@@ -170,31 +170,31 @@ export function* parse(input: string, options: ParseOptions & {
     }
 
     // Comment found at start of new line
-    if (comments && row.length === 0 && input.substring(cursor, cursor + commentsLen) === comments) {
+    if (comments && row.length === 0 && text.substring(cursor, cursor + commentsLen) === comments) {
       if (nextNewline === -1) {
         // Comment ends at EOF
         return
       }
       cursor = nextNewline + newlineLen
-      nextNewline = input.indexOf(newline, cursor)
-      nextDelim = input.indexOf(delimiter, cursor)
+      nextNewline = text.indexOf(newline, cursor)
+      nextDelim = text.indexOf(delimiter, cursor)
       continue
     }
 
     // Next delimiter comes before next newline, so we've reached end of field
     if (nextDelim !== -1 && (nextDelim < nextNewline || nextNewline === -1)) {
-      row.push(input.substring(cursor, nextDelim))
+      row.push(text.substring(cursor, nextDelim))
       cursor = nextDelim + delimLen
       // we look for next delimiter char
-      nextDelim = input.indexOf(delimiter, cursor)
+      nextDelim = text.indexOf(delimiter, cursor)
       continue
     }
 
     // End of row
     if (nextNewline !== -1) {
-      row.push(input.substring(cursor, nextNewline))
+      row.push(text.substring(cursor, nextNewline))
       cursor = nextNewline + newlineLen
-      nextNewline = input.indexOf(newline, cursor)
+      nextNewline = text.indexOf(newline, cursor)
 
       yield getResult()
       row = []
@@ -213,17 +213,17 @@ export function* parse(input: string, options: ParseOptions & {
   return
 
   /**
-   * Appends the remaining input from cursor to the end into
+   * Appends the remaining text from cursor to the end into
    * row, saves the row, calls step, and returns the results.
-   * @param value The remaining input to append
+   * @param value The remaining text to append
    * @returns The results object
    */
   function finish(value?: string): ParseResult | undefined {
     if (ignoreLastRow)
       return
-    value ??= input.substring(cursor)
+    value ??= text.substring(cursor)
     row.push(value)
-    cursor = inputLen
+    cursor = textLen
     // lastCursor = cursor
     return getResult()
   }
@@ -234,7 +234,7 @@ export function* parse(input: string, options: ParseOptions & {
    */
   function getResult(): ParseResult {
     // the row started at lastCursor, ended at cursor
-    const string = input.substring(lastCursor, cursor)
+    const string = text.substring(lastCursor, cursor)
     const byteCount = new TextEncoder().encode(string).length
 
     const result = {
@@ -260,19 +260,19 @@ export function* parse(input: string, options: ParseOptions & {
  * Checks if there are extra spaces after closing quote and given index without any text
  * if Yes, returns the number of spaces
  * @param options Arguments
- * @param options.input The input string
+ * @param options.text The text string
  * @param options.index The index to check up to
  * @param options.quoteSearch The position of the closing quote
  * @returns number of spaces
  */
-function extraSpaces({ input, index, quoteSearch }: {
-  input: string
+function extraSpaces({ text, index, quoteSearch }: {
+  text: string
   index: number
   quoteSearch: number
 }) {
   let spaceLength = 0
   if (index !== -1) {
-    const textBetweenClosingQuoteAndIndex = input.substring(quoteSearch + 1, index)
+    const textBetweenClosingQuoteAndIndex = text.substring(quoteSearch + 1, index)
     if (textBetweenClosingQuoteAndIndex && textBetweenClosingQuoteAndIndex.trim() === '') {
       spaceLength = textBetweenClosingQuoteAndIndex.length
     }

src/string.ts src/text.tssrc/string.ts renamed to src/text.ts

@@ -3,8 +3,8 @@ import { parse } from './parser'
 import type { ParseResult } from './types'
 
 /**
- * Parses a string into CSV data.
- * @param input The input string to parse.
+ * Parses a text into CSV data.
+ * @param text The string to parse.
  * @param options Options for parsing the string.
  * @param options.delimiter The delimiter used in the CSV data. Defaults to ','.
  * @param options.newline The newline used in the CSV data. Defaults to '\n'.
@@ -13,21 +13,21 @@ import type { ParseResult } from './types'
  * @param options.comments The comment character or boolean to indicate comments. Defaults to false (don't strip comments).
  * @param options.delimitersToGuess The list of delimiters to guess from
  * @param options.ignoreLastRow Whether to ignore the last row. Defaults to false.
- * @param options.stripBOM Whether to strip the BOM character at the start of the input. Defaults to true.
+ * @param options.stripBOM Whether to strip the BOM character at the start of the text. Defaults to true.
  * @yields Parsed data and metadata.
  * @returns A generator yielding parsed data and metadata row by row.
  */
-export function* parseString(input: string,
+export function* parseText(text: string,
   options: ParseOptions & {
     delimitersToGuess?: string[]
     ignoreLastRow?: boolean
     stripBOM?: boolean
   } = {}): Generator<ParseResult, void, unknown> {
   const { delimitersToGuess, ignoreLastRow, stripBOM } = options
-  const { parseOptions, error } = validateAndGuessParseOptions(options, { input, delimitersToGuess })
+  const { parseOptions, error } = validateAndGuessParseOptions(options, { text, delimitersToGuess })
 
   let delimiterError: DelimiterError | undefined = error
-  for (const result of parse(input, {
+  for (const result of parse(text, {
     ...parseOptions,
     ignoreLastRow,
     stripBOM,