Function applyObjectDiff

packages/sync-core/src/lib/diff.ts:331–402

(object: T, objectDiff: ObjectDiff)

 * @internal
 */
export function applyObjectDiff<T extends object>(object: T, objectDiff: ObjectDiff): T {
	// don't patch nulls
	if (!object || typeof object !== 'object') return object
	const isArray = Array.isArray(object)
	let newObject: any | undefined = undefined
	const set = (k: any, v: any) => {
		if (!newObject) {
			if (isArray) {
				newObject = [...object]
			} else {
				newObject = { ...object }
			}
		}
		if (isArray) {
			newObject[Number(k)] = v
		} else {
			newObject[k] = v
		}
	}
	for (const [key, op] of Object.entries(objectDiff)) {
		switch (op[0]) {
			case ValueOpType.Put: {
				const value = op[1]
				if (!isEqual(object[key as keyof T], value)) {
					set(key, value)
				}
				break
			}
			case ValueOpType.Append: {
				const value = op[1]
				const offset = op[2]
				const currentValue = object[key as keyof T]
				if (Array.isArray(currentValue) && Array.isArray(value) && currentValue.length === offset) {
					set(key, [...currentValue, ...value])
				} else if (
					typeof currentValue === 'string' &&
					typeof value === 'string' &&
					currentValue.length === offset
				) {
					set(key, currentValue + value)
				}
				// If validation fails (type mismatch or length mismatch), silently ignore
				break
			}
			case ValueOpType.Patch: {
				if (object[key as keyof T] && typeof object[key as keyof T] === 'object') {
					const diff = op[1]
					const patched = applyObjectDiff(object[key as keyof T] as object, diff)
					if (patched !== object[key as keyof T]) {
						set(key, patched)
					}
				}
				break
			}
			case ValueOpType.Delete: {
				if (key in object) {
					if (!newObject) {
						if (isArray) {