@tldraw/store 5.2.0-next.e2b8d10bf10e → 5.2.0

package/src/lib/RecordsDiff.test.ts

@@ -9,136 +9,142 @@ import {
 	squashRecordDiffsMutable,
 } from './RecordsDiff'
 
-// Test interface for testing
-interface TestBook extends BaseRecord<'book', RecordId<TestBook>> {
+// Tests for SPEC.md §4 (RecordsDiff).
+// Rule IDs like [D3] in test names refer to that document.
+
+interface Book extends BaseRecord<'book', RecordId<Book>> {
 	title: string
-	author: string
-	pages: number
 }
 
-// Helper functions to create test records
-function createBook(id: string, title: string, author: string, pages: number = 100): TestBook {
-	return {
-		id: id as RecordId<TestBook>,
-		typeName: 'book',
-		title,
-		author,
-		pages,
-	}
+function book(id: string, title: string): Book {
+	return { id: id as RecordId<Book>, typeName: 'book', title }
 }
 
-// Helper to create a diff
-function createDiff<R extends TestBook>(
-	added: Record<string, R> = {},
-	updated: Record<string, [R, R]> = {},
-	removed: Record<string, R> = {}
-): RecordsDiff<R> {
-	return {
-		added: added as any,
-		updated: updated as any,
-		removed: removed as any,
-	}
+function diff(
+	added: Record<string, Book> = {},
+	updated: Record<string, [Book, Book]> = {},
+	removed: Record<string, Book> = {}
+): RecordsDiff<Book> {
+	return { added, updated, removed } as RecordsDiff<Book>
 }
 
-describe('isRecordsDiffEmpty', () => {
-	it('should return true for empty diffs and false for non-empty diffs', () => {
-		const emptyDiff = createEmptyRecordsDiff<TestBook>()
-		expect(isRecordsDiffEmpty(emptyDiff)).toBe(true)
+describe('empty diffs (D)', () => {
+	it('[D1] createEmptyRecordsDiff returns a diff with empty collections', () => {
+		expect(createEmptyRecordsDiff()).toEqual({ added: {}, updated: {}, removed: {} })
+	})
+
+	it('[D1] isRecordsDiffEmpty is true exactly when all three collections are empty', () => {
+		expect(isRecordsDiffEmpty(createEmptyRecordsDiff())).toBe(true)
+
+		expect(isRecordsDiffEmpty(diff({ 'book:1': book('book:1', 'a') }))).toBe(false)
+		expect(
+			isRecordsDiffEmpty(diff({}, { 'book:1': [book('book:1', 'a'), book('book:1', 'b')] }))
+		).toBe(false)
+		expect(isRecordsDiffEmpty(diff({}, {}, { 'book:1': book('book:1', 'a') }))).toBe(false)
+	})
+})
 
-		const addedDiff = createDiff<TestBook>({ 'book:1': createBook('book:1', 'Test', 'Author') })
-		expect(isRecordsDiffEmpty(addedDiff)).toBe(false)
+describe('reversing diffs (D)', () => {
+	it('[D2] swaps added and removed and reverses updated pairs', () => {
+		const added = book('book:1', 'Added')
+		const from = book('book:2', 'Old')
+		const to = book('book:2', 'New')
+		const removed = book('book:3', 'Removed')
 
-		const oldBook = createBook('book:1', 'Old Title', 'Author')
-		const newBook = createBook('book:1', 'New Title', 'Author')
-		const updatedDiff = createDiff<TestBook>({}, { 'book:1': [oldBook, newBook] })
-		expect(isRecordsDiffEmpty(updatedDiff)).toBe(false)
+		const reversed = reverseRecordsDiff(
+			diff({ 'book:1': added }, { 'book:2': [from, to] }, { 'book:3': removed })
+		)
 
-		const removedDiff = createDiff<TestBook>(
-			{},
-			{},
-			{ 'book:1': createBook('book:1', 'Deleted', 'Author') }
+		expect(reversed).toEqual(
+			diff({ 'book:3': removed }, { 'book:2': [to, from] }, { 'book:1': added })
 		)
-		expect(isRecordsDiffEmpty(removedDiff)).toBe(false)
 	})
 })
 
-describe('reverseRecordsDiff', () => {
-	it('should reverse all operation types correctly', () => {
-		const addedBook = createBook('book:1', 'Added Book', 'Author')
-		const oldUpdatedBook = createBook('book:2', 'Old Title', 'Author')
-		const newUpdatedBook = createBook('book:2', 'New Title', 'Author')
-		const removedBook = createBook('book:3', 'Removed Book', 'Author')
-
-		const originalDiff = createDiff<TestBook>(
-			{ 'book:1': addedBook },
-			{ 'book:2': [oldUpdatedBook, newUpdatedBook] },
-			{ 'book:3': removedBook }
+describe('squashing diffs (D)', () => {
+	it('[D3] add then update becomes an add with the final value', () => {
+		const v1 = book('book:1', 'v1')
+		const v2 = book('book:1', 'v2')
+		expect(squashRecordDiffs([diff({ 'book:1': v1 }), diff({}, { 'book:1': [v1, v2] })])).toEqual(
+			diff({ 'book:1': v2 })
 		)
+	})
 
-		const reversedDiff = reverseRecordsDiff(originalDiff)
+	it('[D3] add then remove cancels out', () => {
+		const b = book('book:1', 'a')
+		expect(squashRecordDiffs([diff({ 'book:1': b }), diff({}, {}, { 'book:1': b })])).toEqual(
+			createEmptyRecordsDiff()
+		)
+	})
 
-		// Added becomes removed
-		expect(reversedDiff.removed['book:1']).toEqual(addedBook)
-		// Removed becomes added
-		expect(reversedDiff.added['book:3']).toEqual(removedBook)
-		// Updated swaps from/to
-		expect(reversedDiff.updated['book:2']).toEqual([newUpdatedBook, oldUpdatedBook])
+	it('[D3] update then update collapses from the original from to the final to', () => {
+		const v1 = book('book:1', 'v1')
+		const v2 = book('book:1', 'v2')
+		const v3 = book('book:1', 'v3')
+		expect(
+			squashRecordDiffs([diff({}, { 'book:1': [v1, v2] }), diff({}, { 'book:1': [v2, v3] })])
+		).toEqual(diff({}, { 'book:1': [v1, v3] }))
 	})
-})
 
-describe('squashRecordDiffs', () => {
-	it('should handle core diff squashing operations', () => {
-		// Add then update becomes single add with final state
-		const initialBook = createBook('book:1', 'Initial Title', 'Author')
-		const updatedBook = createBook('book:1', 'Updated Title', 'Author')
-
-		const diff1 = createDiff<TestBook>({ 'book:1': initialBook })
-		const diff2 = createDiff<TestBook>({}, { 'book:1': [initialBook, updatedBook] })
-		const result1 = squashRecordDiffs([diff1, diff2])
-		expect(result1).toEqual(createDiff<TestBook>({ 'book:1': updatedBook }))
-
-		// Add then remove cancels out
-		const book = createBook('book:1', 'Test Book', 'Author')
-		const diff3 = createDiff<TestBook>({ 'book:1': book })
-		const diff4 = createDiff<TestBook>({}, {}, { 'book:1': book })
-		const result2 = squashRecordDiffs([diff3, diff4])
-		expect(result2).toEqual(createEmptyRecordsDiff<TestBook>())
-
-		// Remove then add becomes update
-		const originalBook = createBook('book:1', 'Original', 'Author')
-		const newBook = createBook('book:1', 'New', 'Author')
-		const diff5 = createDiff<TestBook>({}, {}, { 'book:1': originalBook })
-		const diff6 = createDiff<TestBook>({ 'book:1': newBook })
-		const result3 = squashRecordDiffs([diff5, diff6])
-		expect(result3).toEqual(createDiff<TestBook>({}, { 'book:1': [originalBook, newBook] }))
-
-		// Chain updates together
-		const v1 = createBook('book:1', 'Version 1', 'Author')
-		const v2 = createBook('book:1', 'Version 2', 'Author')
-		const v3 = createBook('book:1', 'Version 3', 'Author')
-		const diff7 = createDiff<TestBook>({}, { 'book:1': [v1, v2] })
-		const diff8 = createDiff<TestBook>({}, { 'book:1': [v2, v3] })
-		const result4 = squashRecordDiffs([diff7, diff8])
-		expect(result4).toEqual(createDiff<TestBook>({}, { 'book:1': [v1, v3] }))
+	it('[D3] update then remove becomes a remove of the original from', () => {
+		const v1 = book('book:1', 'v1')
+		const v2 = book('book:1', 'v2')
+		expect(
+			squashRecordDiffs([diff({}, { 'book:1': [v1, v2] }), diff({}, {}, { 'book:1': v2 })])
+		).toEqual(diff({}, {}, { 'book:1': v1 }))
 	})
-})
 
-describe('squashRecordDiffsMutable', () => {
-	it('should maintain consistency with squashRecordDiffs', () => {
-		const book1 = createBook('book:1', 'Book 1', 'Author')
-		const book2Old = createBook('book:2', 'Book 2 Old', 'Author')
-		const book2New = createBook('book:2', 'Book 2 New', 'Author')
+	it('[D3] remove then add becomes an update', () => {
+		const original = book('book:1', 'Original')
+		const replacement = book('book:1', 'New')
+		expect(
+			squashRecordDiffs([diff({}, {}, { 'book:1': original }), diff({ 'book:1': replacement })])
+		).toEqual(diff({}, { 'book:1': [original, replacement] }))
+	})
+
+	it('[D3] remove then add of the identical object cancels out', () => {
+		const same = book('book:1', 'Same')
+		expect(squashRecordDiffs([diff({}, {}, { 'book:1': same }), diff({ 'book:1': same })])).toEqual(
+			createEmptyRecordsDiff()
+		)
+	})
+
+	it('[D4] does not mutate its inputs by default', () => {
+		const v1 = book('book:1', 'v1')
+		const v2 = book('book:1', 'v2')
+		const first = diff({ 'book:1': v1 })
+		const second = diff({}, { 'book:1': [v1, v2] })
+
+		squashRecordDiffs([first, second])
+
+		expect(first).toEqual(diff({ 'book:1': v1 }))
+		expect(second).toEqual(diff({}, { 'book:1': [v1, v2] }))
+	})
+
+	it('[D4] mutateFirstDiff applies the result onto the first diff in place', () => {
+		const v1 = book('book:1', 'v1')
+		const v2 = book('book:1', 'v2')
+		const first = diff({ 'book:1': v1 })
+
+		const result = squashRecordDiffs([first, diff({}, { 'book:1': [v1, v2] })], {
+			mutateFirstDiff: true,
+		})
+
+		expect(result).toBe(first)
+		expect(first).toEqual(diff({ 'book:1': v2 }))
+	})
 
-		const diff1 = createDiff<TestBook>({ 'book:1': book1 })
-		const diff2 = createDiff<TestBook>({}, { 'book:2': [book2Old, book2New] })
+	it('[D4] squashRecordDiffsMutable agrees with squashRecordDiffs', () => {
+		const added = book('book:1', 'Book 1')
+		const from = book('book:2', 'Old')
+		const to = book('book:2', 'New')
 
-		// Test immutable version
-		const immutableResult = squashRecordDiffs([diff1, diff2])
+		const diffs = [diff({ 'book:1': added }), diff({}, { 'book:2': [from, to] })]
 
-		// Test mutable version
-		const mutableTarget = createEmptyRecordsDiff<TestBook>()
-		squashRecordDiffsMutable(mutableTarget, [diff1, diff2])
+		const immutableResult = squashRecordDiffs(diffs)
+		const mutableTarget = createEmptyRecordsDiff<Book>()
+		squashRecordDiffsMutable(mutableTarget, diffs)
 
-		expect(immutableResult).toEqual(mutableTarget)
+		expect(mutableTarget).toEqual(immutableResult)
 	})
 })

package/src/lib/RecordsDiff.ts

@@ -1,4 +1,3 @@
-import { objectMapEntries } from '@tldraw/utils'
 import { IdOf, UnknownRecord } from './BaseRecord'
 
 /**
@@ -107,11 +106,16 @@ export function reverseRecordsDiff(diff: RecordsDiff<any>) {
  * @public
  */
 export function isRecordsDiffEmpty<T extends UnknownRecord>(diff: RecordsDiff<T>) {
-	return (
-		Object.keys(diff.added).length === 0 &&
-		Object.keys(diff.updated).length === 0 &&
-		Object.keys(diff.removed).length === 0
-	)
+	return !hasAnyKey(diff.added) && !hasAnyKey(diff.updated) && !hasAnyKey(diff.removed)
+}
+
+// Cheaper than Object.keys().length, but note that for-in still pays an O(N)
+// key-collection prologue on dictionary-mode objects (which diffs become once keys
+// are deleted from them) — avoid calling this on large diffs in per-frame hot paths.
+/** @internal */
+export function hasAnyKey(obj: object) {
+	for (const _ in obj) return true
+	return false
 }
 
 /**
@@ -203,9 +207,22 @@ export function squashRecordDiffsMutable<T extends UnknownRecord>(
 	target: RecordsDiff<T>,
 	diffs: RecordsDiff<T>[]
 ): void {
+	// This runs on every history interceptor call — e.g. once per input tick while
+	// resizing N shapes, with N entries in diff.updated — so the updated loop must not
+	// allocate per entry. We use for-in instead of Object.entries, mutate the target's
+	// existing [from, to] tuples in place, and skip delete calls against collections we
+	// know are empty. In-place tuple mutation is safe because the target exclusively
+	// owns its updated tuples: they are always created here (never shared with a source
+	// diff), and sources are never mutated.
 	for (const diff of diffs) {
-		for (const [id, value] of objectMapEntries(diff.added)) {
-			if (target.removed[id]) {
+		// target.removed can only lose entries before the removed loop below, so a
+		// stale `true` is harmless (extra no-op deletes).
+		const targetHasRemoved = hasAnyKey(target.removed)
+
+		for (const _id in diff.added) {
+			const id = _id as IdOf<T>
+			const value = diff.added[id]
+			if (targetHasRemoved && target.removed[id]) {
 				const original = target.removed[id]
 				delete target.removed[id]
 				if (original !== value) {
@@ -216,24 +233,32 @@ export function squashRecordDiffsMutable<T extends UnknownRecord>(
 			}
 		}
 
-		for (const [id, [_from, to]] of objectMapEntries(diff.updated)) {
-			if (target.added[id]) {
+		// the added loop above may have inserted into target.added
+		const targetHasAdded = hasAnyKey(target.added)
+
+		for (const _id in diff.updated) {
+			const id = _id as IdOf<T>
+			const to = diff.updated[id][1]
+			if (targetHasAdded && target.added[id]) {
 				target.added[id] = to
 				delete target.updated[id]
-				delete target.removed[id]
+				if (targetHasRemoved) delete target.removed[id]
 				continue
 			}
-			if (target.updated[id]) {
-				target.updated[id] = [target.updated[id][0], to]
-				delete target.removed[id]
+			const existing = target.updated[id]
+			if (existing) {
+				existing[1] = to
+				if (targetHasRemoved) delete target.removed[id]
 				continue
 			}
 
-			target.updated[id] = diff.updated[id]
-			delete target.removed[id]
+			// copy the tuple so the target owns it and can mutate it in place later
+			target.updated[id] = [diff.updated[id][0], to]
+			if (targetHasRemoved) delete target.removed[id]
 		}
 
-		for (const [id, value] of objectMapEntries(diff.removed)) {
+		for (const _id in diff.removed) {
+			const id = _id as IdOf<T>
 			// the same record was added in this diff sequence, just drop it
 			if (target.added[id]) {
 				delete target.added[id]
@@ -241,7 +266,7 @@ export function squashRecordDiffsMutable<T extends UnknownRecord>(
 				target.removed[id] = target.updated[id][0]
 				delete target.updated[id]
 			} else {
-				target.removed[id] = value
+				target.removed[id] = diff.removed[id]
 			}
 		}
 	}