@pgcorp/ui-kit 0.9.0 → 0.10.0

package/src/internal/diffEngine.ts

@@ -0,0 +1,464 @@
+import type {
+  SDiffComputationOptions,
+  SDiffGap,
+  SDiffHunk,
+  SDiffLine,
+  SDiffLineBreak,
+  SDiffLineKind,
+  SDiffLineSide,
+  SDiffResult,
+  SDiffSource,
+  SDiffSourceSnapshot,
+} from '../components/shared/data-display/diff'
+
+interface DiffToken {
+  readonly text: string
+  readonly lineBreak: SDiffLineBreak
+}
+
+interface DiffOperation {
+  readonly kind: SDiffLineKind
+  readonly beforeIndex?: number
+  readonly afterIndex?: number
+}
+
+export type DiffCancellationProbe = () => boolean
+
+export class DiffEngineCancelledError extends Error {
+  constructor() {
+    super('Diff computation was cancelled.')
+    this.name = 'DiffEngineCancelledError'
+  }
+}
+
+const CANCELLATION_CHECK_INTERVAL = 1024
+
+class CancellationCheckpoint {
+  private operations = 0
+
+  constructor(private readonly isCancelled: DiffCancellationProbe | undefined) {}
+
+  check(force = false): void {
+    this.operations += 1
+    if (!force && this.operations % CANCELLATION_CHECK_INTERVAL !== 0) return
+    if (this.isCancelled?.() === true) throw new DiffEngineCancelledError()
+  }
+}
+
+function tokenize(text: string): readonly DiffToken[] {
+  if (text.length === 0) return Object.freeze([])
+  const tokens: DiffToken[] = []
+  let start = 0
+  for (let index = 0; index < text.length; index += 1) {
+    if (text[index] !== '\n') continue
+    const hasCarriageReturn = index > start && text[index - 1] === '\r'
+    tokens.push(Object.freeze({
+      text: text.slice(start, hasCarriageReturn ? index - 1 : index),
+      lineBreak: hasCarriageReturn ? 'crlf' : 'lf',
+    }))
+    start = index + 1
+  }
+  if (start < text.length) {
+    tokens.push(Object.freeze({ text: text.slice(start), lineBreak: 'none' }))
+  }
+  return Object.freeze(tokens)
+}
+
+function tokensEqual(left: DiffToken, right: DiffToken): boolean {
+  return left.text === right.text && left.lineBreak === right.lineBreak
+}
+
+function findToken(
+  tokens: readonly DiffToken[],
+  start: number,
+  end: number,
+  target: DiffToken,
+  checkpoint: CancellationCheckpoint,
+): number {
+  for (let index = start; index < end; index += 1) {
+    checkpoint.check()
+    if (tokensEqual(tokens[index], target)) return index
+  }
+  return -1
+}
+
+function emitRemoved(operations: DiffOperation[], start: number, end: number): void {
+  for (let index = start; index < end; index += 1) {
+    operations.push({ kind: 'removed', beforeIndex: index })
+  }
+}
+
+function emitAdded(operations: DiffOperation[], start: number, end: number): void {
+  for (let index = start; index < end; index += 1) {
+    operations.push({ kind: 'added', afterIndex: index })
+  }
+}
+
+function emitUnchanged(
+  operations: DiffOperation[],
+  beforeStart: number,
+  afterStart: number,
+  length: number,
+): void {
+  for (let offset = 0; offset < length; offset += 1) {
+    operations.push({
+      kind: 'unchanged',
+      beforeIndex: beforeStart + offset,
+      afterIndex: afterStart + offset,
+    })
+  }
+}
+
+interface BisectSplit {
+  readonly before: number
+  readonly after: number
+}
+
+function findBisectSplit(
+  before: readonly DiffToken[],
+  beforeStart: number,
+  beforeEnd: number,
+  after: readonly DiffToken[],
+  afterStart: number,
+  afterEnd: number,
+  checkpoint: CancellationCheckpoint,
+): BisectSplit | null {
+  const beforeLength = beforeEnd - beforeStart
+  const afterLength = afterEnd - afterStart
+  const maxDistance = Math.ceil((beforeLength + afterLength) / 2)
+  const vectorOffset = maxDistance
+  const vectorLength = maxDistance * 2 + 1
+  const forward = new Int32Array(vectorLength)
+  const reverse = new Int32Array(vectorLength)
+  forward.fill(-1)
+  reverse.fill(-1)
+  forward[vectorOffset + 1] = 0
+  reverse[vectorOffset + 1] = 0
+  const delta = beforeLength - afterLength
+  const frontOverlap = delta % 2 !== 0
+  let forwardStart = 0
+  let forwardEnd = 0
+  let reverseStart = 0
+  let reverseEnd = 0
+
+  for (let distance = 0; distance < maxDistance; distance += 1) {
+    checkpoint.check(true)
+    for (
+      let diagonal = -distance + forwardStart;
+      diagonal <= distance - forwardEnd;
+      diagonal += 2
+    ) {
+      const vectorIndex = vectorOffset + diagonal
+      let beforeOffset = diagonal === -distance
+        || (diagonal !== distance && forward[vectorIndex - 1] < forward[vectorIndex + 1])
+        ? forward[vectorIndex + 1]
+        : forward[vectorIndex - 1] + 1
+      let afterOffset = beforeOffset - diagonal
+      while (
+        beforeOffset < beforeLength
+        && afterOffset < afterLength
+        && tokensEqual(before[beforeStart + beforeOffset], after[afterStart + afterOffset])
+      ) {
+        checkpoint.check()
+        beforeOffset += 1
+        afterOffset += 1
+      }
+      forward[vectorIndex] = beforeOffset
+      if (beforeOffset > beforeLength) forwardEnd += 2
+      else if (afterOffset > afterLength) forwardStart += 2
+      else if (frontOverlap) {
+        const reverseDiagonal = delta - diagonal
+        const reverseIndex = vectorOffset + reverseDiagonal
+        if (
+          reverseIndex >= 0
+          && reverseIndex < vectorLength
+          && reverse[reverseIndex] !== -1
+          && beforeOffset >= beforeLength - reverse[reverseIndex]
+        ) {
+          return {
+            before: beforeStart + beforeOffset,
+            after: afterStart + afterOffset,
+          }
+        }
+      }
+    }
+
+    for (
+      let diagonal = -distance + reverseStart;
+      diagonal <= distance - reverseEnd;
+      diagonal += 2
+    ) {
+      const vectorIndex = vectorOffset + diagonal
+      let beforeOffset = diagonal === -distance
+        || (diagonal !== distance && reverse[vectorIndex - 1] < reverse[vectorIndex + 1])
+        ? reverse[vectorIndex + 1]
+        : reverse[vectorIndex - 1] + 1
+      let afterOffset = beforeOffset - diagonal
+      while (
+        beforeOffset < beforeLength
+        && afterOffset < afterLength
+        && tokensEqual(before[beforeEnd - beforeOffset - 1], after[afterEnd - afterOffset - 1])
+      ) {
+        checkpoint.check()
+        beforeOffset += 1
+        afterOffset += 1
+      }
+      reverse[vectorIndex] = beforeOffset
+      if (beforeOffset > beforeLength) reverseEnd += 2
+      else if (afterOffset > afterLength) reverseStart += 2
+      else if (!frontOverlap) {
+        const forwardDiagonal = delta - diagonal
+        const forwardIndex = vectorOffset + forwardDiagonal
+        if (
+          forwardIndex >= 0
+          && forwardIndex < vectorLength
+          && forward[forwardIndex] !== -1
+          && forward[forwardIndex] >= beforeLength - beforeOffset
+        ) {
+          const splitBefore = beforeStart + forward[forwardIndex]
+          return {
+            before: splitBefore,
+            after: afterStart + splitBefore - beforeStart - forwardDiagonal,
+          }
+        }
+      }
+    }
+  }
+  return null
+}
+
+function diffRange(
+  before: readonly DiffToken[],
+  beforeStartValue: number,
+  beforeEndValue: number,
+  after: readonly DiffToken[],
+  afterStartValue: number,
+  afterEndValue: number,
+  operations: DiffOperation[],
+  checkpoint: CancellationCheckpoint,
+): void {
+  checkpoint.check(true)
+  let beforeStart = beforeStartValue
+  let afterStart = afterStartValue
+  while (
+    beforeStart < beforeEndValue
+    && afterStart < afterEndValue
+    && tokensEqual(before[beforeStart], after[afterStart])
+  ) {
+    checkpoint.check()
+    operations.push({ kind: 'unchanged', beforeIndex: beforeStart, afterIndex: afterStart })
+    beforeStart += 1
+    afterStart += 1
+  }
+
+  let beforeEnd = beforeEndValue
+  let afterEnd = afterEndValue
+  let suffixLength = 0
+  while (
+    beforeStart < beforeEnd
+    && afterStart < afterEnd
+    && tokensEqual(before[beforeEnd - 1], after[afterEnd - 1])
+  ) {
+    checkpoint.check()
+    beforeEnd -= 1
+    afterEnd -= 1
+    suffixLength += 1
+  }
+
+  const beforeLength = beforeEnd - beforeStart
+  const afterLength = afterEnd - afterStart
+  if (beforeLength === 0) emitAdded(operations, afterStart, afterEnd)
+  else if (afterLength === 0) emitRemoved(operations, beforeStart, beforeEnd)
+  else if (beforeLength === 1) {
+    const match = findToken(after, afterStart, afterEnd, before[beforeStart], checkpoint)
+    if (match === -1) {
+      emitRemoved(operations, beforeStart, beforeEnd)
+      emitAdded(operations, afterStart, afterEnd)
+    } else {
+      emitAdded(operations, afterStart, match)
+      emitUnchanged(operations, beforeStart, match, 1)
+      emitAdded(operations, match + 1, afterEnd)
+    }
+  } else if (afterLength === 1) {
+    const match = findToken(before, beforeStart, beforeEnd, after[afterStart], checkpoint)
+    if (match === -1) {
+      emitRemoved(operations, beforeStart, beforeEnd)
+      emitAdded(operations, afterStart, afterEnd)
+    } else {
+      emitRemoved(operations, beforeStart, match)
+      emitUnchanged(operations, match, afterStart, 1)
+      emitRemoved(operations, match + 1, beforeEnd)
+    }
+  } else {
+    const split = findBisectSplit(
+      before,
+      beforeStart,
+      beforeEnd,
+      after,
+      afterStart,
+      afterEnd,
+      checkpoint,
+    )
+    if (
+      split === null
+      || (split.before === beforeStart && split.after === afterStart)
+      || (split.before === beforeEnd && split.after === afterEnd)
+    ) {
+      emitRemoved(operations, beforeStart, beforeEnd)
+      emitAdded(operations, afterStart, afterEnd)
+    } else {
+      diffRange(before, beforeStart, split.before, after, afterStart, split.after, operations, checkpoint)
+      diffRange(before, split.before, beforeEnd, after, split.after, afterEnd, operations, checkpoint)
+    }
+  }
+
+  emitUnchanged(operations, beforeEnd, afterEnd, suffixLength)
+}
+
+function createLineSide(token: DiffToken, lineNumber: number): SDiffLineSide {
+  return Object.freeze({ lineNumber, text: token.text, lineBreak: token.lineBreak })
+}
+
+function buildLines(
+  before: readonly DiffToken[],
+  after: readonly DiffToken[],
+  operations: readonly DiffOperation[],
+): readonly SDiffLine[] {
+  return Object.freeze(operations.map((operation) => {
+    const beforeIndex = operation.beforeIndex
+    const afterIndex = operation.afterIndex
+    const beforeSide = beforeIndex === undefined
+      ? undefined
+      : createLineSide(before[beforeIndex], beforeIndex + 1)
+    const afterSide = afterIndex === undefined
+      ? undefined
+      : createLineSide(after[afterIndex], afterIndex + 1)
+    const beforeCoordinate = beforeIndex === undefined ? '-' : String(beforeIndex + 1)
+    const afterCoordinate = afterIndex === undefined ? '-' : String(afterIndex + 1)
+    return Object.freeze({
+      id: `line:${operation.kind}:${beforeCoordinate}:${afterCoordinate}`,
+      kind: operation.kind,
+      ...(beforeSide === undefined ? {} : { before: beforeSide }),
+      ...(afterSide === undefined ? {} : { after: afterSide }),
+    })
+  }))
+}
+
+function buildPrefixCounts(lines: readonly SDiffLine[]): {
+  readonly before: Int32Array
+  readonly after: Int32Array
+} {
+  const before = new Int32Array(lines.length + 1)
+  const after = new Int32Array(lines.length + 1)
+  for (let index = 0; index < lines.length; index += 1) {
+    before[index + 1] = before[index] + (lines[index].before === undefined ? 0 : 1)
+    after[index + 1] = after[index] + (lines[index].after === undefined ? 0 : 1)
+  }
+  return { before, after }
+}
+
+function buildHunksAndGaps(
+  lines: readonly SDiffLine[],
+  contextLines: number,
+): { readonly hunks: readonly SDiffHunk[]; readonly gaps: readonly SDiffGap[] } {
+  const changedIndices: number[] = []
+  lines.forEach((line, index) => {
+    if (line.kind !== 'unchanged') changedIndices.push(index)
+  })
+  if (changedIndices.length === 0) {
+    return { hunks: Object.freeze([]), gaps: Object.freeze([]) }
+  }
+
+  const windows: Array<{ start: number; end: number }> = []
+  for (const changedIndex of changedIndices) {
+    const start = Math.max(0, changedIndex - contextLines)
+    const end = Math.min(lines.length, changedIndex + contextLines + 1)
+    const previous = windows[windows.length - 1]
+    if (previous !== undefined && start <= previous.end) previous.end = Math.max(previous.end, end)
+    else windows.push({ start, end })
+  }
+
+  const prefix = buildPrefixCounts(lines)
+  const hunks = windows.map((window) => Object.freeze({
+    id: `hunk:${prefix.before[window.start] + 1}:${prefix.after[window.start] + 1}`,
+    lineStart: window.start,
+    lineEnd: window.end,
+    beforeStart: prefix.before[window.start] + 1,
+    beforeLineCount: prefix.before[window.end] - prefix.before[window.start],
+    afterStart: prefix.after[window.start] + 1,
+    afterLineCount: prefix.after[window.end] - prefix.after[window.start],
+  }))
+  const gaps: SDiffGap[] = []
+  let previousEnd = 0
+  for (const window of windows) {
+    if (window.start > previousEnd) {
+      const lineCount = window.start - previousEnd
+      gaps.push(Object.freeze({
+        id: `gap:${prefix.before[previousEnd] + 1}:${prefix.after[previousEnd] + 1}:${lineCount}`,
+        lineStart: previousEnd,
+        lineEnd: window.start,
+        beforeStart: prefix.before[previousEnd] + 1,
+        afterStart: prefix.after[previousEnd] + 1,
+        lineCount,
+      }))
+    }
+    previousEnd = window.end
+  }
+  if (previousEnd < lines.length) {
+    const lineCount = lines.length - previousEnd
+    gaps.push(Object.freeze({
+      id: `gap:${prefix.before[previousEnd] + 1}:${prefix.after[previousEnd] + 1}:${lineCount}`,
+      lineStart: previousEnd,
+      lineEnd: lines.length,
+      beforeStart: prefix.before[previousEnd] + 1,
+      afterStart: prefix.after[previousEnd] + 1,
+      lineCount,
+    }))
+  }
+  return { hunks: Object.freeze(hunks), gaps: Object.freeze(gaps) }
+}
+
+function snapshot(source: SDiffSource, lineCount: number): SDiffSourceSnapshot {
+  return Object.freeze({
+    lineCount,
+    ...(source.label === undefined ? {} : { label: source.label }),
+    ...(source.revision === undefined ? {} : { revision: source.revision }),
+    ...(source.language === undefined ? {} : { language: source.language }),
+  })
+}
+
+/** Pure deterministic engine used by both direct computation and the module worker. */
+export function computeDiffModel(
+  beforeSource: SDiffSource,
+  afterSource: SDiffSource,
+  options: Required<SDiffComputationOptions>,
+  isCancelled?: DiffCancellationProbe,
+): SDiffResult {
+  const checkpoint = new CancellationCheckpoint(isCancelled)
+  checkpoint.check(true)
+  const before = tokenize(beforeSource.text)
+  const after = tokenize(afterSource.text)
+  const operations: DiffOperation[] = []
+  diffRange(before, 0, before.length, after, 0, after.length, operations, checkpoint)
+  checkpoint.check(true)
+  const lines = buildLines(before, after, operations)
+  const { hunks, gaps } = buildHunksAndGaps(lines, options.contextLines)
+  const unchangedLineCount = lines.filter((line) => line.kind === 'unchanged').length
+  const removedLineCount = lines.filter((line) => line.kind === 'removed').length
+  const addedLineCount = lines.filter((line) => line.kind === 'added').length
+  return Object.freeze({
+    before: snapshot(beforeSource, before.length),
+    after: snapshot(afterSource, after.length),
+    lines,
+    hunks,
+    gaps,
+    summary: Object.freeze({
+      beforeLineCount: before.length,
+      afterLineCount: after.length,
+      unchangedLineCount,
+      removedLineCount,
+      addedLineCount,
+      changedLineCount: removedLineCount + addedLineCount,
+    }),
+  })
+}

package/src/internal/diffRuntime.ts

@@ -0,0 +1,189 @@
+import {
+  computeDiff,
+  validateDiffComputationOptions,
+  validateDiffSource,
+  type SDiffComputationOptions,
+  type SDiffResult,
+  type SDiffSource,
+} from '../components/shared/data-display/diff'
+import {
+  S_DIFF_WORKER_PROTOCOL_VERSION,
+  validateDiffWorkerResponse,
+  type SDiffWorkerRequest,
+} from '../workers/diffProtocol'
+
+export const S_DIFF_WORKER_TEXT_THRESHOLD = 32_768
+export const S_DIFF_WORKER_LINE_THRESHOLD = 1_200
+
+export interface SDiffWorkerLike {
+  postMessage(message: SDiffWorkerRequest): void
+  addEventListener(type: 'message', listener: (event: MessageEvent<unknown>) => void): void
+  addEventListener(type: 'error', listener: (event: ErrorEvent) => void): void
+  removeEventListener(type: 'message', listener: (event: MessageEvent<unknown>) => void): void
+  removeEventListener(type: 'error', listener: (event: ErrorEvent) => void): void
+  terminate(): void
+}
+
+export type SDiffWorkerFactory = () => SDiffWorkerLike
+
+export interface SDiffRuntime {
+  compute(
+    before: SDiffSource,
+    after: SDiffSource,
+    options?: SDiffComputationOptions,
+    signal?: AbortSignal,
+  ): Promise<SDiffResult>
+  dispose(): void
+}
+
+export class SDiffComputationCancelledError extends Error {
+  constructor(message = 'Diff computation was cancelled.') {
+    super(message)
+    this.name = 'SDiffComputationCancelledError'
+  }
+}
+
+interface ActiveRequest {
+  readonly cancel: (message?: string) => void
+}
+
+function countLines(text: string): number {
+  if (text.length === 0) return 0
+  let lineCount = text.endsWith('\n') ? 0 : 1
+  for (const character of text) {
+    if (character === '\n') lineCount += 1
+  }
+  return lineCount
+}
+
+export function shouldUseDiffWorker(before: SDiffSource, after: SDiffSource): boolean {
+  return before.text.length + after.text.length >= S_DIFF_WORKER_TEXT_THRESHOLD
+    || countLines(before.text) + countLines(after.text) >= S_DIFF_WORKER_LINE_THRESHOLD
+}
+
+function createDefaultWorker(): SDiffWorkerLike {
+  return new Worker(new URL('../workers/diff.worker.ts', import.meta.url), {
+    type: 'module',
+    name: 's-ui-kit-diff',
+  })
+}
+
+/** Creates an instance-owned worker runtime. Disposal cancels every retained computation resource. */
+export function createDiffRuntime(workerFactory: SDiffWorkerFactory = createDefaultWorker): SDiffRuntime {
+  let requestSequence = 0
+  let disposed = false
+  const activeRequests = new Map<string, ActiveRequest>()
+
+  const computeInWorker = (
+    before: SDiffSource,
+    after: SDiffSource,
+    options: Required<SDiffComputationOptions>,
+    signal: AbortSignal | undefined,
+  ): Promise<SDiffResult> => {
+    const requestId = `diff-request-${requestSequence += 1}`
+    const worker = workerFactory()
+    return new Promise<SDiffResult>((resolve, reject) => {
+      let settled = false
+      const cleanup = (): void => {
+        signal?.removeEventListener('abort', onAbort)
+        worker.removeEventListener('message', onMessage)
+        worker.removeEventListener('error', onError)
+        worker.terminate()
+        activeRequests.delete(requestId)
+      }
+      const failCancelled = (message?: string): void => {
+        if (settled) return
+        settled = true
+        try {
+          worker.postMessage({
+            version: S_DIFF_WORKER_PROTOCOL_VERSION,
+            type: 'cancel',
+            requestId,
+          })
+        } catch (cause) {
+          cleanup()
+          reject(cause)
+          return
+        }
+        cleanup()
+        reject(new SDiffComputationCancelledError(message))
+      }
+      const onAbort = (): void => failCancelled('Diff computation was aborted.')
+      const onError = (event: ErrorEvent): void => {
+        if (settled) return
+        settled = true
+        cleanup()
+        reject(new Error(`Diff worker failed: ${event.message}`))
+      }
+      const onMessage = (event: MessageEvent<unknown>): void => {
+        if (settled) return
+        let response
+        try {
+          response = validateDiffWorkerResponse(event.data)
+        } catch (cause) {
+          settled = true
+          cleanup()
+          reject(cause)
+          return
+        }
+        if (response.requestId !== requestId) {
+          settled = true
+          cleanup()
+          reject(new Error(
+            `Diff worker returned requestId ${JSON.stringify(response.requestId)} for active ${JSON.stringify(requestId)}.`,
+          ))
+          return
+        }
+        settled = true
+        cleanup()
+        if (response.type === 'result') resolve(response.result)
+        else if (response.type === 'cancelled') reject(new SDiffComputationCancelledError())
+        else {
+          const error = new Error(response.error.message)
+          error.name = response.error.name
+          reject(error)
+        }
+      }
+      activeRequests.set(requestId, { cancel: failCancelled })
+      signal?.addEventListener('abort', onAbort, { once: true })
+      worker.addEventListener('message', onMessage)
+      worker.addEventListener('error', onError)
+      try {
+        worker.postMessage({
+          version: S_DIFF_WORKER_PROTOCOL_VERSION,
+          type: 'compute',
+          requestId,
+          before,
+          after,
+          options,
+        })
+      } catch (cause) {
+        settled = true
+        cleanup()
+        reject(cause)
+      }
+    })
+  }
+
+  return Object.freeze({
+    async compute(
+      beforeValue: SDiffSource,
+      afterValue: SDiffSource,
+      optionsValue?: SDiffComputationOptions,
+      signal?: AbortSignal,
+    ): Promise<SDiffResult> {
+      if (disposed) throw new Error('Diff runtime is disposed.')
+      if (signal?.aborted === true) throw new SDiffComputationCancelledError('Diff computation was aborted.')
+      const before = validateDiffSource('SDiffRuntime', 'before', beforeValue)
+      const after = validateDiffSource('SDiffRuntime', 'after', afterValue)
+      const options = validateDiffComputationOptions('SDiffRuntime', optionsValue)
+      if (!shouldUseDiffWorker(before, after)) return computeDiff(before, after, options)
+      return computeInWorker(before, after, options, signal)
+    },
+    dispose(): void {
+      if (disposed) return
+      disposed = true
+      for (const request of [...activeRequests.values()]) request.cancel('Diff runtime was disposed.')
+    },
+  })
+}