wip: make types happy

Author: Julusian

meteor/server/api/deviceTriggers/RundownsObserver.ts

@@ -1,68 +1,75 @@
 import { Meteor } from 'meteor/meteor'
 import { RundownId, RundownPlaylistId } from '@sofie-automation/corelib/dist/dataModel/Ids'
-import _ from 'underscore'
 import { Rundowns } from '../../collections'
 import { literal } from '@sofie-automation/corelib/dist/lib'
 import { MongoFieldSpecifierOnesStrict } from '@sofie-automation/corelib/dist/mongo'
 import { DBRundown } from '@sofie-automation/corelib/dist/dataModel/Rundown'
+import { PromiseDebounce } from '../../publications/lib/debounce'
 
 const REACTIVITY_DEBOUNCE = 20
 
-type ChangedHandler = (rundownIds: RundownId[]) => () => void
+type ChangedHandler = (rundownIds: RundownId[]) => Promise<() => void>
 
 type RundownFields = '_id'
 const rundownFieldSpecifier = literal<MongoFieldSpecifierOnesStrict<Pick<DBRundown, RundownFields>>>({
 	_id: 1,
 })
 
 export class RundownsObserver {
-	#rundownsLiveQuery: Meteor.LiveQueryHandle
+	#rundownsLiveQuery!: Meteor.LiveQueryHandle
 	#rundownIds: Set<RundownId> = new Set<RundownId>()
 	#changed: ChangedHandler | undefined
 	#cleanup: (() => void) | undefined
 
-	constructor(activePlaylistId: RundownPlaylistId, onChanged: ChangedHandler) {
+	readonly #triggerUpdateRundownContent = new PromiseDebounce(async () => {
+		if (!this.#changed) return
+		this.#cleanup?.()
+
+		const changed = this.#changed
+		this.#cleanup = await changed(this.rundownIds)
+	}, REACTIVITY_DEBOUNCE)
+
+	private constructor(onChanged: ChangedHandler) {
 		this.#changed = onChanged
-		this.#rundownsLiveQuery = Rundowns.observeChanges(
+	}
+
+	static async create(playlistId: RundownPlaylistId, onChanged: ChangedHandler): Promise<RundownsObserver> {
+		const observer = new RundownsObserver(onChanged)
+
+		await observer.init(playlistId)
+
+		return observer
+	}
+
+	private async init(activePlaylistId: RundownPlaylistId) {
+		this.#rundownsLiveQuery = await Rundowns.observeChanges(
 			{
 				playlistId: activePlaylistId,
 			},
 			{
 				added: (rundownId) => {
 					this.#rundownIds.add(rundownId)
-					this.updateRundownContent()
+					this.#triggerUpdateRundownContent.trigger()
 				},
 				removed: (rundownId) => {
 					this.#rundownIds.delete(rundownId)
-					this.updateRundownContent()
+					this.#triggerUpdateRundownContent.trigger()
 				},
 			},
 			{
 				projection: rundownFieldSpecifier,
 			}
 		)
-		this.updateRundownContent()
+
+		this.#triggerUpdateRundownContent.trigger()
 	}
 
 	public get rundownIds(): RundownId[] {
 		return Array.from(this.#rundownIds)
 	}
 
-	private innerUpdateRundownContent = () => {
-		if (!this.#changed) return
-		this.#cleanup?.()
-
-		const changed = this.#changed
-		this.#cleanup = changed(this.rundownIds)
-	}
-
-	public updateRundownContent = _.debounce(
-		Meteor.bindEnvironment(this.innerUpdateRundownContent),
-		REACTIVITY_DEBOUNCE
-	)
-
 	public stop = (): void => {
-		this.updateRundownContent.cancel()
+		this.#triggerUpdateRundownContent.cancelWaiting()
 		this.#rundownsLiveQuery.stop()
 		this.#changed = undefined
 		this.#cleanup?.()

meteor/server/api/deviceTriggers/StudioObserver.ts

@@ -20,6 +20,7 @@ import { ContentCache } from './reactiveContentCache'
 import { RundownContentObserver } from './RundownContentObserver'
 import { RundownsObserver } from './RundownsObserver'
 import { RundownPlaylists, Rundowns, ShowStyleBases } from '../../collections'
+import { PromiseDebounce } from '../../publications/lib/debounce'
 
 type ChangedHandler = (showStyleBaseId: ShowStyleBaseId, cache: ContentCache) => () => void
 
@@ -146,77 +147,67 @@ export class StudioObserver extends EventEmitter {
 					  ) as Promise<MongoCursor<Pick<DBShowStyleBase, ShowStyleBaseFields>>>)
 					: null
 			)
-			.end(this.updateShowStyle)
+			.end(this.updateShowStyle.call)
 	}
 
-	private updateShowStyle = _.debounce(
-		Meteor.bindEnvironment(
-			(
-				state: {
-					currentRundown: Pick<DBRundown, RundownFields>
-					showStyleBase: Pick<DBShowStyleBase, ShowStyleBaseFields>
-				} | null
-			) => {
-				const showStyleBaseId = state?.showStyleBase._id
-
-				if (
-					showStyleBaseId === undefined ||
-					!this.nextProps?.activePlaylistId ||
-					!this.nextProps?.activationId
-				) {
-					this.currentProps = undefined
-					this.#rundownsLiveQuery?.stop()
-					this.#rundownsLiveQuery = undefined
-					this.showStyleBaseId = showStyleBaseId
-					return
+	private readonly updateShowStyle = new PromiseDebounce<
+		void,
+		[
+			{
+				currentRundown: Pick<DBRundown, RundownFields>
+				showStyleBase: Pick<DBShowStyleBase, ShowStyleBaseFields>
+			} | null
+		]
+	>(async (state): Promise<void> => {
+		const showStyleBaseId = state?.showStyleBase._id
+
+		if (showStyleBaseId === undefined || !this.nextProps?.activePlaylistId || !this.nextProps?.activationId) {
+			this.currentProps = undefined
+			this.#rundownsLiveQuery?.stop()
+			this.#rundownsLiveQuery = undefined
+			this.showStyleBaseId = showStyleBaseId
+			return
+		}
+
+		if (
+			showStyleBaseId === this.showStyleBaseId &&
+			this.nextProps?.activationId === this.currentProps?.activationId &&
+			this.nextProps?.activePlaylistId === this.currentProps?.activePlaylistId &&
+			this.nextProps?.currentRundownId === this.currentProps?.currentRundownId
+		)
+			return
+
+		this.#rundownsLiveQuery?.stop()
+		this.#rundownsLiveQuery = undefined
+
+		this.currentProps = this.nextProps
+		this.nextProps = undefined
+
+		const { activePlaylistId } = this.currentProps
+
+		this.showStyleBaseId = showStyleBaseId
+
+		let cleanupChanges: (() => void) | undefined = undefined
+
+		this.#rundownsLiveQuery = await RundownsObserver.create(activePlaylistId, async (rundownIds) => {
+			logger.silly(`Creating new RundownContentObserver`)
+			const obs1 = await RundownContentObserver.create(activePlaylistId, showStyleBaseId, rundownIds, (cache) => {
+				cleanupChanges = this.#changed(showStyleBaseId, cache)
+
+				return () => {
+					void 0
 				}
+			})
 
-				if (
-					showStyleBaseId === this.showStyleBaseId &&
-					this.nextProps?.activationId === this.currentProps?.activationId &&
-					this.nextProps?.activePlaylistId === this.currentProps?.activePlaylistId &&
-					this.nextProps?.currentRundownId === this.currentProps?.currentRundownId
-				)
-					return
-
-				this.#rundownsLiveQuery?.stop()
-				this.#rundownsLiveQuery = undefined
-
-				this.currentProps = this.nextProps
-				this.nextProps = undefined
-
-				const { activePlaylistId } = this.currentProps
-
-				this.showStyleBaseId = showStyleBaseId
-
-				let cleanupChanges: (() => void) | undefined = undefined
-
-				this.#rundownsLiveQuery = new RundownsObserver(activePlaylistId, async (rundownIds) => {
-					logger.silly(`Creating new RundownContentObserver`)
-					const obs1 = await RundownContentObserver.create(
-						activePlaylistId,
-						showStyleBaseId,
-						rundownIds,
-						(cache) => {
-							cleanupChanges = this.#changed(showStyleBaseId, cache)
-
-							return () => {
-								void 0
-							}
-						}
-					)
-
-					return () => {
-						obs1.stop()
-						cleanupChanges?.()
-					}
-				})
+			return () => {
+				obs1.stop()
+				cleanupChanges?.()
 			}
-		),
-		REACTIVITY_DEBOUNCE
-	)
+		})
+	}, REACTIVITY_DEBOUNCE)
 
 	public stop = (): void => {
+		this.updateShowStyle.cancelWaiting()
 		this.#playlistInStudioLiveQuery.stop()
 		this.updatePlaylistInStudio.cancel()
 	}

meteor/server/publications/lib/debounce.ts

@@ -5,18 +5,18 @@ import { Meteor } from 'meteor/meteor'
  * With additional features:
  * - `cancel` method
  */
-export class PromiseDebounce<TResult> {
-	readonly #fn: () => Promise<TResult>
+export class PromiseDebounce<TResult = void, TArgs extends unknown[] = []> {
+	readonly #fn: (...args: TArgs) => Promise<TResult>
 	readonly #wait: number
 
 	/** If an execution timeout has passed while  */
-	#isPending = false
+	#pendingArgs: TArgs | null = null
 	#timeout: number | undefined
 
 	#isExecuting = false
 	#waitingListeners: Listener<TResult>[] = []
 
-	constructor(fn: () => Promise<TResult>, wait: number) {
+	constructor(fn: (...args: TArgs) => Promise<TResult>, wait: number) {
 		this.#fn = fn
 		this.#wait = wait
 	}
@@ -25,22 +25,25 @@ export class PromiseDebounce<TResult> {
 	 * Trigger an execution, and get the result.
 	 * @returns A promise that resolves with the result of the function
 	 */
-	async call(): Promise<TResult> {
+	async call(...args: TArgs): Promise<TResult> {
 		return new Promise<TResult>((resolve, reject) => {
 			const listener: Listener<TResult> = { resolve, reject }
 			this.#waitingListeners.push(listener)
 
 			// Trigger an execution
-			this.trigger()
+			this.trigger(...args)
 		})
 	}
 
 	/**
 	 * Trigger an execution, but don't report the result.
 	 */
-	trigger(): void {
+	trigger(...args: TArgs): void {
 		// If an execution is 'imminent', don't do anything
-		if (this.#isPending) return
+		if (this.#pendingArgs) {
+			this.#pendingArgs = args
+			return
+		}
 
 		// Clear an existing timeout
 		if (this.#timeout) Meteor.clearTimeout(this.#timeout)
@@ -49,26 +52,26 @@ export class PromiseDebounce<TResult> {
 		this.#timeout = Meteor.setTimeout(() => {
 			this.#timeout = undefined
 
-			this.#executeFn()
+			this.#executeFn(args)
 		}, this.#wait)
 	}
 
-	#executeFn(): void {
+	#executeFn(args: TArgs): void {
 		// If an execution is still in progress, mark as pending and stop
 		if (this.#isExecuting) {
-			this.#isPending = true
+			this.#pendingArgs = args
 			return
 		}
 
 		// We have the clear to begin executing
 		this.#isExecuting = true
-		this.#isPending = false
+		this.#pendingArgs = null
 
 		// Collect up the listeners for this execution
 		const listeners = this.#waitingListeners
 		this.#waitingListeners = []
 
-		this.#fn()
+		this.#fn(...args)
 			.then((result) => {
 				for (const listener of listeners) {
 					try {
@@ -91,8 +94,9 @@ export class PromiseDebounce<TResult> {
 				this.#isExecuting = false
 
 				// If there is a pending execution, run that soon
-				if (this.#isPending) {
-					Meteor.setTimeout(() => this.#executeFn(), 0)
+				if (this.#pendingArgs) {
+					const args = this.#pendingArgs
+					Meteor.setTimeout(() => this.#executeFn(args), 0)
 				}
 			})
 	}
@@ -101,7 +105,7 @@ export class PromiseDebounce<TResult> {
 	 * Cancel any waiting execution
 	 */
 	cancelWaiting(error?: Error): void {
-		this.#isPending = false
+		this.#pendingArgs = null
 
 		if (this.#timeout) {
 			Meteor.clearTimeout(this.#timeout)

meteor/server/publications/lib/rundownsObserver.ts

@@ -17,7 +17,7 @@ export class RundownsObserver implements Meteor.LiveQueryHandle {
 	#changed: ChangedHandler | undefined
 	#cleanup: (() => void) | undefined
 
-	readonly #triggerUpdateRundownContent = new PromiseDebounce<void>(async () => {
+	readonly #triggerUpdateRundownContent = new PromiseDebounce(async () => {
 		if (!this.#changed) return
 		this.#cleanup?.()