improvement(ui): reduce large-paste admission overhead

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/paste-admission.ts

@@ -34,9 +34,14 @@ export function createRichMarkdownPasteAdmission({
                 const currentText = getCurrentText()
                 const { from, to } = view.state.selection
                 const replacedText = view.state.doc.textBetween(from, to, '\n')
+                const replacesWholeDocument = from <= 1 && to >= view.state.doc.content.size - 1
+                const projectedCharacters = replacesWholeDocument
+                  ? pastedText.length
+                  : Math.max(0, currentText.length - replacedText.length) + pastedText.length
+                if (projectedCharacters <= Math.floor(maxResultBytes / 3)) return false
+
                 const currentBytes = utf8ByteLength(currentText, maxResultBytes)
                 const pastedBytes = utf8ByteLength(pastedText, maxResultBytes)
-                const replacesWholeDocument = from <= 1 && to >= view.state.doc.content.size - 1
                 const replacedBytes = replacesWholeDocument
                   ? currentBytes
                   : utf8ByteLength(replacedText, maxResultBytes)

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-paste.test.ts

@@ -22,6 +22,13 @@ describe('parseBoundedTsv', () => {
   it('preserves an intentional empty final cell', () => {
     expect(parseBoundedTsv('a\t', 2)).toEqual({ rows: [['a', '']], maxColumns: 2 })
   })
+
+  it('preserves interior blank rows and classic Mac row separators', () => {
+    expect(parseBoundedTsv('a\r\rb', 2)).toEqual({
+      rows: [['a'], [''], ['b']],
+      maxColumns: 1,
+    })
+  })
 })
 
 describe('exceedsTablePasteRowLimit', () => {

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-paste.ts

@@ -21,47 +21,31 @@ export function parseBoundedTsv(text: string, columnLimit: number): ParsedTableP
   if (!text || columnLimit < 1) return { rows: [], maxColumns: 0 }
 
   const rows: string[][] = []
-  let row: string[] = []
-  let column = 0
-  let cellStart = 0
   let maxColumns = 0
-
-  const finishCell = (end: number) => {
-    if (column < columnLimit) row.push(text.slice(cellStart, end))
-    column += 1
-  }
-
-  const finishRow = () => {
-    if (row.length > 0) {
-      maxColumns = Math.max(maxColumns, row.length)
-      rows.push(row)
-    }
-    row = []
-    column = 0
-  }
-
-  for (let index = 0; index <= text.length; index++) {
-    if (index === text.length) {
-      if (cellStart < text.length || column > 0) {
-        finishCell(index)
-        finishRow()
+  const pushRow = (rowStart: number, rowEnd: number) => {
+    const row: string[] = []
+    let cellStart = rowStart
+    while (row.length < columnLimit) {
+      const tab = text.indexOf('\t', cellStart)
+      if (tab < 0 || tab >= rowEnd) {
+        row.push(text.slice(cellStart, rowEnd))
+        break
       }
-      break
-    }
-
-    const code = text.charCodeAt(index)
-    if (code === 9) {
-      finishCell(index)
-      cellStart = index + 1
-      continue
+      row.push(text.slice(cellStart, tab))
+      cellStart = tab + 1
     }
-    if (code !== 10 && code !== 13) continue
+    maxColumns = Math.max(maxColumns, row.length)
+    rows.push(row)
+  }
 
-    finishCell(index)
-    finishRow()
-    if (code === 13 && text.charCodeAt(index + 1) === 10) index += 1
-    cellStart = index + 1
+  let rowStart = 0
+  const rowBreak = /\r\n|\r|\n/g
+  let match: RegExpExecArray | null
+  while ((match = rowBreak.exec(text))) {
+    pushRow(rowStart, match.index)
+    rowStart = rowBreak.lastIndex
   }
+  if (rowStart < text.length) pushRow(rowStart, text.length)
 
   return { rows, maxColumns }
 }

packages/utils/src/paste.test.ts

@@ -52,6 +52,12 @@ describe('assessTextPaste', () => {
     })
   })
 
+  it('accepts payloads with worst-case UTF-8 headroom without measuring exact bytes', () => {
+    expect(assessTextPaste({ pastedText: '💡'.repeat(100), maxPastedBytes: 1_000 })).toEqual({
+      accepted: true,
+    })
+  })
+
   it('rejects a projected result above its character limit', () => {
     expect(
       assessTextPaste({

packages/utils/src/paste.ts

@@ -100,6 +100,10 @@ export function utf8ByteLength(value: string, stopAfter = Number.POSITIVE_INFINI
   return utf8ByteLengthRange(value, 0, value.length, stopAfter)
 }
 
+function isGuaranteedWithinUtf8Limit(characters: number, limit: number): boolean {
+  return characters <= Math.floor(limit / 3)
+}
+
 function normalizedSelection(input: TextPasteAdmissionInput): {
   currentText: string
   start: number
@@ -139,6 +143,40 @@ export function assessTextPaste(input: TextPasteAdmissionInput): TextPasteAdmiss
     }
   }
 
+  const projectsResult =
+    input.maxResultBytes !== undefined || input.maxResultCharacters !== undefined
+  if (
+    !projectsResult &&
+    input.maxPastedBytes !== undefined &&
+    isGuaranteedWithinUtf8Limit(pastedText.length, input.maxPastedBytes)
+  ) {
+    return { accepted: true }
+  }
+
+  const selection = projectsResult ? normalizedSelection(input) : null
+  const resultCharacters = selection
+    ? selection.currentText.length - (selection.end - selection.start) + pastedText.length
+    : undefined
+  if (
+    input.maxResultCharacters !== undefined &&
+    resultCharacters !== undefined &&
+    resultCharacters > input.maxResultCharacters
+  ) {
+    return {
+      accepted: false,
+      reason: 'result-characters',
+      actual: resultCharacters,
+      limit: input.maxResultCharacters,
+    }
+  }
+  if (
+    input.maxResultBytes !== undefined &&
+    resultCharacters !== undefined &&
+    isGuaranteedWithinUtf8Limit(resultCharacters, input.maxResultBytes)
+  ) {
+    return { accepted: true, resultCharacters }
+  }
+
   const pastedByteLimit = Math.max(input.maxPastedBytes ?? 0, input.maxResultBytes ?? 0)
   const pastedBytes = pastedByteLimit > 0 ? utf8ByteLength(pastedText, pastedByteLimit) : undefined
 
@@ -155,20 +193,11 @@ export function assessTextPaste(input: TextPasteAdmissionInput): TextPasteAdmiss
     }
   }
 
-  if (input.maxResultBytes === undefined && input.maxResultCharacters === undefined) {
+  if (!projectsResult) {
     return { accepted: true, pastedBytes }
   }
 
-  const { currentText, start, end } = normalizedSelection(input)
-  const resultCharacters = currentText.length - (end - start) + pastedText.length
-  if (input.maxResultCharacters !== undefined && resultCharacters > input.maxResultCharacters) {
-    return {
-      accepted: false,
-      reason: 'result-characters',
-      actual: resultCharacters,
-      limit: input.maxResultCharacters,
-    }
-  }
+  const { currentText, start, end } = selection as ReturnType<typeof normalizedSelection>
 
   if (input.maxResultBytes === undefined) {
     return { accepted: true, pastedBytes, resultCharacters }