remove cursor and charOffset from meta, and row and index from error + add tests

Author: severo

src/parser.ts

@@ -75,8 +75,6 @@ export function* parse(text: string, options: ParseOptions & {
             type: 'Quotes',
             code: 'MissingQuotes',
             message: 'Quoted field unterminated',
-            // row: data.length, // row has yet to be inserted
-            index: cursor,
           })
           const last = finish()
           if (last) {
@@ -158,8 +156,6 @@ export function* parse(text: string, options: ParseOptions & {
           type: 'Quotes',
           code: 'InvalidQuotes',
           message: 'Trailing quote on quoted field is malformed',
-          // row: data.length, // row has yet to be inserted
-          index: cursor,
         })
 
         quoteSearch++
@@ -224,7 +220,6 @@ export function* parse(text: string, options: ParseOptions & {
     value ??= text.substring(cursor)
     row.push(value)
     cursor = textLen
-    // lastCursor = cursor
     return getResult()
   }
 
@@ -245,9 +240,7 @@ export function* parse(text: string, options: ParseOptions & {
         newline,
         byteOffset,
         byteCount,
-        charOffset: lastCursor,
         charCount: string.length,
-        cursor, // it's the next charOffset
       },
     }
     lastCursor = cursor

src/types.d.ts

@@ -11,49 +11,37 @@ export interface ParseError {
     | 'InvalidQuotes'
   /** Human-readable details */
   message: string
-  /** Row index of parsed data where error is */
-  row?: number | undefined
-  /** Index within the row where error is */
-  index?: number | undefined
 }
 
 export interface ParseMeta {
   /** Delimiter used */
   delimiter: string
   /** Line break sequence used */
   newline: string
-  /** Character position after the parsed row */
-  cursor: number
-  /** Byte position where parsing started */
-  //   firstByte: number
-  /** Number of bytes parsed, including line breaks, BOM, spaces, etc. */
-  //   numBytes: number
-
   /** Byte offset at the start of the row */
   byteOffset: number
   /** Number of bytes consumed in this row */
   byteCount: number
-  /** Character offset at the start of the row */
-  charOffset: number
   /** Number of characters consumed in this row */
   charCount: number
 }
 
 /**
- * A parse result always contains three objects: data, errors, and meta.
- * Data and errors are arrays, and meta is an object. In the step callback, the data array will only contain one element.
+ * A parse result always contains three objects: row, errors, and meta.
+ * row and errors are arrays, and meta is an object.
  */
 export interface ParseResult {
   /**
    * the cells of the parsed row.
    */
   row: string[]
-  /** an array of errors. */
+  /**
+   * an array of errors.
+   */
   errors: ParseError[]
   /**
    * 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.
+   * the newline sequence, etc.
    */
   meta: ParseMeta
 }

tests/cases.ts

@@ -22,7 +22,7 @@ export const CORE_PARSER_TESTS = [
       meta: {
         byteOffset: 0,
         byteCount: 5,
-        cursor: 5,
+        charCount: 5,
         delimiter: ',',
         newline: '\n',
       },
@@ -37,7 +37,7 @@ export const CORE_PARSER_TESTS = [
       meta: {
         byteOffset: 0,
         byteCount: 5,
-        cursor: 22,
+        charCount: 11,
         delimiter: ',',
         newline: '\n',
       },
@@ -567,7 +567,7 @@ export const CORE_PARSER_TESTS = [
       errors: [],
       meta: {
         // renamedHeaders: { A_1: 'A', A_2: 'A', A_3: 'A' },
-        cursor: 15,
+        charCount: 15,
       },
     },
   },
@@ -582,7 +582,7 @@ export const CORE_PARSER_TESTS = [
       errors: [],
       meta: {
         // renamedHeaders: { c_2: 'c', c_3: 'c' },
-        cursor: 17,
+        charCount: 17,
       },
     },
   },
@@ -597,7 +597,7 @@ export const CORE_PARSER_TESTS = [
       errors: [],
       meta: {
         // renamedHeaders: { __proto___1: '__proto__', __proto___2: '__proto__' },
-        cursor: 35,
+        charCount: 35,
       },
     },
   },
@@ -1078,80 +1078,80 @@ export const PARSE_TESTS = [
     },
   },
   {
-    description: 'Using \\r\\n endings uses \\r\\n linebreak',
+    description: 'Using \\r\\n endings uses \\r\\n newline',
     text: 'a,b\r\nc,d\r\ne,f\r\ng,h\r\ni,j',
     config: {},
     expected: {
       data: [['a', 'b'], ['c', 'd'], ['e', 'f'], ['g', 'h'], ['i', 'j']],
       errors: [],
       meta: {
-        linebreak: '\r\n',
+        newline: '\r\n',
         delimiter: ',',
-        cursor: 23,
+        charCount: 23,
         aborted: false,
         renamedHeaders: null,
       },
     },
   },
   {
-    description: 'Using \\n endings uses \\n linebreak',
+    description: 'Using \\n endings uses \\n newline',
     text: 'a,b\nc,d\ne,f\ng,h\ni,j',
     config: {},
     expected: {
       data: [['a', 'b'], ['c', 'd'], ['e', 'f'], ['g', 'h'], ['i', 'j']],
       errors: [],
       meta: {
-        linebreak: '\n',
+        newline: '\n',
         delimiter: ',',
-        cursor: 19,
+        charCount: 19,
         aborted: false,
         renamedHeaders: null,
       },
     },
   },
   {
-    description: 'Using \\r\\n endings with \\r\\n in header field uses \\r\\n linebreak',
+    description: 'Using \\r\\n endings with \\r\\n in header field uses \\r\\n newline',
     text: '"a\r\na",b\r\nc,d\r\ne,f\r\ng,h\r\ni,j',
     config: {},
     expected: {
       data: [['a\r\na', 'b'], ['c', 'd'], ['e', 'f'], ['g', 'h'], ['i', 'j']],
       errors: [],
       meta: {
-        linebreak: '\r\n',
+        newline: '\r\n',
         delimiter: ',',
-        cursor: 28,
+        charCount: 28,
         aborted: false,
         renamedHeaders: null,
       },
     },
   },
   {
-    description: 'Using \\r\\n endings with \\n in header field uses \\r\\n linebreak',
+    description: 'Using \\r\\n endings with \\n in header field uses \\r\\n newline',
     text: '"a\na",b\r\nc,d\r\ne,f\r\ng,h\r\ni,j',
     config: {},
     expected: {
       data: [['a\na', 'b'], ['c', 'd'], ['e', 'f'], ['g', 'h'], ['i', 'j']],
       errors: [],
       meta: {
-        linebreak: '\r\n',
+        newline: '\r\n',
         delimiter: ',',
-        cursor: 27,
+        charCount: 27,
         aborted: false,
         renamedHeaders: null,
       },
     },
   },
   {
-    description: 'Using \\n endings with \\r\\n in header field uses \\n linebreak',
+    description: 'Using \\n endings with \\r\\n in header field uses \\n newline',
     text: '"a\r\na",b\nc,d\ne,f\ng,h\ni,j',
     config: {},
     expected: {
       data: [['a\r\na', 'b'], ['c', 'd'], ['e', 'f'], ['g', 'h'], ['i', 'j']],
       errors: [],
       meta: {
-        linebreak: '\n',
+        newline: '\n',
         delimiter: ',',
-        cursor: 24,
+        charCount: 24,
         aborted: false,
         renamedHeaders: null,
       },
@@ -1165,9 +1165,9 @@ export const PARSE_TESTS = [
       data: [['a\na', 'b'], ['c', 'd'], ['e', 'f'], ['g', 'h'], ['i', 'j']],
       errors: [],
       meta: {
-        linebreak: '\r\n',
+        newline: '\r\n',
         delimiter: ',',
-        cursor: 27,
+        charCount: 27,
         aborted: false,
         renamedHeaders: null,
       },
@@ -1181,9 +1181,9 @@ export const PARSE_TESTS = [
       data: [['a\na', 'b'], ['c', 'd'], ['e', 'f'], ['g', 'h'], ['i', 'j']],
       errors: [],
       meta: {
-        linebreak: '\r\n',
+        newline: '\r\n',
         delimiter: ',',
-        cursor: 27,
+        charCount: 27,
         aborted: false,
         renamedHeaders: null,
       },

tests/parser.test.ts

@@ -12,7 +12,20 @@ describe('Papaparse core parser tests', () => {
       const errors = result.flatMap(({ errors: rowErrors }, row) => rowErrors.map(error => ({ ...error, row })))
       expect(data).toEqual(test.expected.data)
       expect(errors).toEqual(test.expected.errors)
-      // TODO(SL): meta test
+      if (test.expected.meta?.charCount !== undefined) {
+        const charCount = result.reduce((acc, { meta }) => acc + (meta.charCount || 0), 0)
+        expect(charCount).toBe(test.expected.meta?.charCount)
+      }
+      if (test.expected.meta?.newline !== undefined) {
+        const newlines = new Set(result.map(({ meta }) => meta.newline))
+        expect(newlines.size).toBe(1)
+        expect(newlines.has(test.expected.meta?.newline)).toBe(true)
+      }
+      if (test.expected.meta?.delimiter !== undefined) {
+        const delimiters = new Set(result.map(({ meta }) => meta.delimiter))
+        expect(delimiters.size).toBe(1)
+        expect(delimiters.has(test.expected.meta?.delimiter)).toBe(true)
+      }
     })
   })
 })
@@ -98,11 +111,11 @@ describe('parse', () => {
 
     expect(meta[0]?.byteOffset).toBe(0)
     expect(meta[0]?.byteCount).toBe(9) // 'a,b,😊\n' (9 bytes)
-    expect(meta[0]?.cursor).toBe(7) // 'a,b,😊\n' (7 characters, 😊 counts for 1 character)
+    expect(meta[0]?.charCount).toBe(7) // 'a,b,😊\n' (7 characters, 😊 counts for 1 character)
 
     expect(meta[1]?.byteOffset).toBe(9)
     expect(meta[1]?.byteCount).toBe(8) // '1,2,😂' (8 bytes)
-    expect(meta[1]?.cursor).toBe(13) // '1,2,😂' (6 characters, 😂 counts for 2 characters!, + previous cursor: 7)
+    expect(meta[1]?.charCount).toBe(6) // '1,2,😂' (6 characters, 😂 counts for 2 characters!)
 
     expect((meta[1]?.byteOffset ?? NaN) + (meta[1]?.byteCount ?? NaN)).toBe(new TextEncoder().encode(text).length) // total bytes
   })

tests/text.test.ts

@@ -16,12 +16,10 @@ describe('parseText', () => {
         row: ['hello', ' csvremote!!!'],
         errors: [],
         meta: {
-          cursor: text.length,
           delimiter: ',',
           newline: '\n' as const,
           byteOffset: 0,
           byteCount: bytes.length,
-          charOffset: 0,
           charCount: text.length,
         },
       })
@@ -73,7 +71,20 @@ describe('Papaparse high-level tests', () => {
       }))
       expect(data).toEqual(test.expected.data)
       expect(errors).toEqual(test.expected.errors)
-      // TODO(SL): meta test
+      if (test.expected.meta?.charCount !== undefined) {
+        const charCount = result.reduce((acc, { meta }) => acc + (meta.charCount || 0), 0)
+        expect(charCount).toBe(test.expected.meta?.charCount)
+      }
+      if (test.expected.meta?.newline !== undefined) {
+        const newlines = new Set(result.map(({ meta }) => meta.newline))
+        expect(newlines.size).toBe(1)
+        expect(newlines.has(test.expected.meta?.newline)).toBe(true)
+      }
+      if (test.expected.meta?.delimiter !== undefined) {
+        const delimiters = new Set(result.map(({ meta }) => meta.delimiter))
+        expect(delimiters.size).toBe(1)
+        expect(delimiters.has(test.expected.meta?.delimiter)).toBe(true)
+      }
     })
   })
 })

tests/url.test.ts

@@ -14,12 +14,10 @@ function* parseMock(text: string): Generator<ParseResult, void, unknown> {
     meta: {
       byteOffset: 0,
       byteCount: bytes.length,
-      charOffset: 0,
       charCount: text.length,
       newline: '\n',
       // quote: '"',
       delimiter: ',',
-      cursor: text.length,
     },
   }
 }
@@ -111,12 +109,10 @@ describe('parseURL, while mocking parse, ', () => {
         meta: {
           byteOffset: 0,
           byteCount: 2 * text.length,
-          charOffset: 0,
           charCount: 2 * text.length,
           newline: '\n',
           // quote: '"',
           delimiter: ',',
-          cursor: 0, // wrong too
         },
       }
     }
@@ -149,7 +145,20 @@ describe('Papaparse high-level tests', () => {
       }))
       expect(data).toEqual(test.expected.data)
       expect(errors).toEqual(test.expected.errors)
-      // TODO(SL): meta test
+      if (test.expected.meta?.charCount !== undefined) {
+        const charCount = result.reduce((acc, { meta }) => acc + (meta.charCount || 0), 0)
+        expect(charCount).toBe(test.expected.meta?.charCount)
+      }
+      if (test.expected.meta?.newline !== undefined) {
+        const newlines = new Set(result.map(({ meta }) => meta.newline))
+        expect(newlines.size).toBe(1)
+        expect(newlines.has(test.expected.meta?.newline)).toBe(true)
+      }
+      if (test.expected.meta?.delimiter !== undefined) {
+        const delimiters = new Set(result.map(({ meta }) => meta.delimiter))
+        expect(delimiters.size).toBe(1)
+        expect(delimiters.has(test.expected.meta?.delimiter)).toBe(true)
+      }
     })
   })
 })