Merge branch 'contribute/ianshade/EAV-518'

Author: nytamin

src/__tests__/basic.spec.ts

@@ -1783,6 +1783,77 @@ describeVariants(
 			const resolved = resolveTimeline(timeline, { cache: getCache(), time: 0, dontThrowOnError: true })
 			expect(resolved.error).toBeTruthy()
 		})
+		test('Object that start at the same time as another', () => {
+			// An object that start at the same time as another should behave as expected
+			//
+			const timeline = fixTimeline([
+				{
+					id: 'A',
+					enable: { start: 1000 }, // 1000
+					layer: 'L1',
+					content: { value: 'replaced' },
+					priority: 0,
+				},
+				{
+					id: 'B',
+					enable: { start: '#A.start' }, // 1000
+					layer: 'L1',
+					content: { value: 'playing' },
+					priority: 1,
+				},
+				// Same as above, but with ids in different alphabetical order
+				{
+					id: 'D',
+					enable: { start: 1000 }, // 1000
+					layer: 'L2',
+					content: { value: 'replaced' },
+					priority: 0,
+				},
+				{
+					id: 'C',
+					enable: { start: '#D.start' }, // 1000
+					layer: 'L2',
+					content: { value: 'playing' },
+					priority: 1,
+				},
+			])
+			const time = 1010
+			const resolved = resolveTimeline(timeline, { time, cache: getCache() })
+
+			expect(resolved.objects).toMatchObject({
+				A: {
+					resolved: {
+						instances: [{ start: 1000, end: 1000 }],
+					},
+				},
+				B: {
+					resolved: {
+						instances: [{ start: 1000, end: null }],
+					},
+				},
+				D: {
+					resolved: {
+						instances: [{ start: 1000, end: 1000 }],
+					},
+				},
+				C: {
+					resolved: {
+						instances: [{ start: 1000, end: null }],
+					},
+				},
+			})
+
+			const state0 = getResolvedState(resolved, time)
+			expect(state0.time).toEqual(time)
+			expect(state0.layers).toMatchObject({
+				L1: {
+					content: { value: 'playing' },
+				},
+				L2: {
+					content: { value: 'playing' },
+				},
+			})
+		})
 	},
 	{
 		normal: true,

src/__tests__/groups.spec.ts

@@ -1617,6 +1617,45 @@ describeVariants(
 				},
 			])
 		})
+
+		test('Referencing and replacing a same-layer child of a group from the outside', () => {
+			const timeline = fixTimeline([
+				{
+					id: 'group',
+					enable: { start: 1000 },
+					priority: 0,
+					layer: '',
+					content: {},
+					children: [
+						{
+							id: 'obj_inside',
+							enable: { start: 0 },
+							layer: 'L1',
+							content: { value: 'wrong' },
+							priority: 0,
+						},
+					],
+					isGroup: true,
+				},
+				{
+					id: 'obj_outside',
+					enable: { start: '#obj_inside.start' },
+					layer: 'L1',
+					content: { value: 'right' },
+					priority: 1,
+				},
+			])
+			const time = 1000
+			const resolved = resolveTimeline(timeline, { time, cache: getCache() })
+
+			const state0 = getResolvedState(resolved, time)
+			expect(state0.time).toEqual(time)
+			expect(state0.layers).toMatchObject({
+				L1: {
+					content: { value: 'right' },
+				},
+			})
+		})
 	},
 	{
 		normal: true,

src/resolver/LayerStateHandler.ts

@@ -21,7 +21,11 @@ export class LayerStateHandler {
 	constructor(
 		private resolvedTimeline: ResolvedTimelineHandler,
 		private instance: InstanceHandler,
-		private layer: string
+		private layer: string,
+		/**
+		 * Maps an array of object ids to an object id (objects that directly reference an reference).
+		 */
+		private directReferenceMap: Map<string, string[]>
 	) {
 		this.objectsOnLayer = []
 		this.objectIdsOnLayer = this.resolvedTimeline.getLayerObjects(layer)
@@ -117,7 +121,7 @@ export class LayerStateHandler {
 
 			/** List of the instances to check at this point in time. */
 			const instancesToCheck: InstanceAtPointInTime[] = this.pointsInTime[time]
-			instancesToCheck.sort(compareInstancesToCheck)
+			instancesToCheck.sort(this.compareInstancesToCheck)
 
 			for (let j = 0; j < instancesToCheck.length; j++) {
 				const o = instancesToCheck[j]
@@ -268,6 +272,45 @@ export class LayerStateHandler {
 		if (!this.pointsInTime[time + '']) this.pointsInTime[time + ''] = []
 		this.pointsInTime[time + ''].push({ obj, instance, instanceEvent })
 	}
+	private compareInstancesToCheck = (a: InstanceAtPointInTime, b: InstanceAtPointInTime) => {
+		// Note: we assume that there are no keyframes here. (if there where, they would be sorted first)
+
+		if (
+			a.instance.id === b.instance.id &&
+			a.instance.start === b.instance.start &&
+			a.instance.end === b.instance.end
+		) {
+			// A & B are the same instance, it is a zero-length instance!
+			// In this case, put the start before the end:
+			if (a.instanceEvent === 'start' && b.instanceEvent === 'end') return -1
+			if (a.instanceEvent === 'end' && b.instanceEvent === 'start') return 1
+		}
+
+		// Handle ending instances first:
+		if (a.instanceEvent === 'start' && b.instanceEvent === 'end') return 1
+		if (a.instanceEvent === 'end' && b.instanceEvent === 'start') return -1
+
+		if (a.instance.start === a.instance.end || b.instance.start === b.instance.end) {
+			// Put later-ending instances last (in the case of zero-length vs non-zero-length instance):
+			const difference = (a.instance.end ?? Infinity) - (b.instance.end ?? Infinity)
+			if (difference) return difference
+		}
+
+		// If A references B, A should be handled after B, (B might resolve into a zero-length instance)
+		const aRefObjIds = this.directReferenceMap.get(a.obj.id)
+		if (aRefObjIds?.includes(b.obj.id)) return -1
+		const bRefObjIds = this.directReferenceMap.get(b.obj.id)
+		if (bRefObjIds?.includes(a.obj.id)) return 1
+
+		if (a.obj.resolved && b.obj.resolved) {
+			// Deeper objects (children in groups) comes later, we want to check the parent groups first:
+			const difference = a.obj.resolved.levelDeep - b.obj.resolved.levelDeep
+			if (difference) return difference
+		}
+
+		// Last resort, sort by id to make it deterministic:
+		return compareStrings(a.obj.id, b.obj.id) || compareStrings(a.instance.id, b.instance.id)
+	}
 }
 export interface TimeEvent {
 	time: number
@@ -292,36 +335,6 @@ function compareObjectsOnLayer(a: ResolvedTimelineObject, b: ResolvedTimelineObj
 	return a.resolved.levelDeep - b.resolved.levelDeep || compareStrings(a.id, b.id)
 }
 
-function compareInstancesToCheck(a: InstanceAtPointInTime, b: InstanceAtPointInTime) {
-	// Note: we assume that there are no keyframes here. (if there where, they would be sorted first)
-
-	if (a.instance.id === b.instance.id && a.instance.start === b.instance.start && a.instance.end === b.instance.end) {
-		// A & B are the same instance, it is a zero-length instance!
-		// In this case, put the start before the end:
-		if (a.instanceEvent === 'start' && b.instanceEvent === 'end') return -1
-		if (a.instanceEvent === 'end' && b.instanceEvent === 'start') return 1
-	}
-
-	// Handle ending instances first:
-	if (a.instanceEvent === 'start' && b.instanceEvent === 'end') return 1
-	if (a.instanceEvent === 'end' && b.instanceEvent === 'start') return -1
-
-	if (a.instance.start === a.instance.end || b.instance.start === b.instance.end) {
-		// Put later-ending instances last (in the case of zero-length vs non-zero-length instance):
-		const difference = (a.instance.end ?? Infinity) - (b.instance.end ?? Infinity)
-		if (difference) return difference
-	}
-
-	if (a.obj.resolved && b.obj.resolved) {
-		// Deeper objects (children in groups) comes later, we want to check the parent groups first:
-		const difference = a.obj.resolved.levelDeep - b.obj.resolved.levelDeep
-		if (difference) return difference
-	}
-
-	// Last resort, sort by id to make it deterministic:
-	return compareStrings(a.obj.id, b.obj.id) || compareStrings(a.instance.id, b.instance.id)
-}
-
 const removeFromAspiringInstances = (aspiringInstances: AspiringInstance[], objId: string): AspiringInstance[] => {
 	const returnInstances: AspiringInstance[] = []
 	for (let i = 0; i < aspiringInstances.length; i++) {

src/resolver/ResolvedTimelineHandler.ts

@@ -1129,7 +1129,7 @@ export class ResolvedTimelineHandler<TContent extends Content = Content> {
 	 * @returns A list of objects on that layer
 	 */
 	private resolveConflictsForLayer(layer: string): ResolvedTimelineObject[] {
-		const handler = new LayerStateHandler(this, this.instance, layer)
+		const handler = new LayerStateHandler(this, this.instance, layer, this.directReferenceMap)
 
 		// Fast path: If an object on this layer depends on an already changed object we should skip this layer, this iteration.
 		// Because the objects will likely change during the next resolve-iteration anyway.