wip: this probably doesn't work, need to figure out how to do reactivity correctly..

Author: Julusian

packages/meteor-lib/src/triggers/actionFilterChainCompilers.ts

@@ -634,30 +634,34 @@ export function compileAdLibFilter(
 				// because _.isEqual (used in memoizedIsolatedAutorun) doesn't work with Maps..
 
 				const rundownPlaylistId = context.rundownPlaylistId.get()
-				const rundownRanks = await triggersContext.memoizedIsolatedAutorun(async () => {
-					const playlist = (await triggersContext.RundownPlaylists.findOneAsync(rundownPlaylistId, {
-						projection: {
-							rundownIdsInOrder: 1,
-						},
-					})) as Pick<DBRundownPlaylist, 'rundownIdsInOrder'> | undefined
-
-					if (playlist?.rundownIdsInOrder) {
-						return playlist.rundownIdsInOrder
-					} else {
-						const rundowns = (await triggersContext.Rundowns.findFetchAsync(
-							{
-								playlistId: rundownPlaylistId,
+				const rundownRanks = await triggersContext.memoizedIsolatedAutorun(
+					async () => {
+						const playlist = (await triggersContext.RundownPlaylists.findOneAsync(rundownPlaylistId, {
+							projection: {
+								rundownIdsInOrder: 1,
 							},
-							{
-								fields: {
-									_id: 1,
+						})) as Pick<DBRundownPlaylist, 'rundownIdsInOrder'> | undefined
+
+						if (playlist?.rundownIdsInOrder) {
+							return playlist.rundownIdsInOrder
+						} else {
+							const rundowns = (await triggersContext.Rundowns.findFetchAsync(
+								{
+									playlistId: rundownPlaylistId,
 								},
-							}
-						)) as Pick<DBRundown, '_id'>[]
-
-						return rundowns.map((r) => r._id)
-					}
-				}, `rundownsRanksForPlaylist_${rundownPlaylistId}`)
+								{
+									fields: {
+										_id: 1,
+									},
+								}
+							)) as Pick<DBRundown, '_id'>[]
+
+							return rundowns.map((r) => r._id)
+						}
+					},
+					reactive,
+					`rundownsRanksForPlaylist_${rundownPlaylistId}`
+				)
 				rundownRanks.forEach((id, index) => {
 					rundownRankMap.set(id, index)
 				})
@@ -675,41 +679,46 @@ export function compileAdLibFilter(
 								},
 							}
 						)) as Pick<DBSegment, '_id' | '_rank'>[],
+					reactive,
 					`segmentRanksForRundowns_${Array.from(rundownRankMap.keys()).join(',')}`
 				)
 				segmentRanks.forEach((segment) => {
 					segmentRankMap.set(segment._id, segment._rank)
 				})
 
-				const partRanks = await triggersContext.memoizedIsolatedAutorun(async () => {
-					if (!partFilter) {
-						return (await triggersContext.Parts.findFetchAsync(
-							{
-								rundownId: { $in: Array.from(rundownRankMap.keys()) },
-							},
-							{
-								fields: {
-									_id: 1,
-									segmentId: 1,
-									rundownId: 1,
-									_rank: 1,
-								},
-							}
-						)) as Pick<DBPart, '_id' | '_rank' | 'segmentId' | 'rundownId'>[]
-					} else {
-						return (await triggersContext.Parts.findFetchAsync(
-							{ _id: { $in: partFilter } },
-							{
-								fields: {
-									_id: 1,
-									segmentId: 1,
-									rundownId: 1,
-									_rank: 1,
+				const partRanks = await triggersContext.memoizedIsolatedAutorun(
+					async () => {
+						if (!partFilter) {
+							return (await triggersContext.Parts.findFetchAsync(
+								{
+									rundownId: { $in: Array.from(rundownRankMap.keys()) },
 								},
-							}
-						)) as Pick<DBPart, '_id' | '_rank' | 'segmentId' | 'rundownId'>[]
-					}
-				}, `partRanks_${JSON.stringify(partFilter ?? rundownRankMap.keys())}`)
+								{
+									fields: {
+										_id: 1,
+										segmentId: 1,
+										rundownId: 1,
+										_rank: 1,
+									},
+								}
+							)) as Pick<DBPart, '_id' | '_rank' | 'segmentId' | 'rundownId'>[]
+						} else {
+							return (await triggersContext.Parts.findFetchAsync(
+								{ _id: { $in: partFilter } },
+								{
+									fields: {
+										_id: 1,
+										segmentId: 1,
+										rundownId: 1,
+										_rank: 1,
+									},
+								}
+							)) as Pick<DBPart, '_id' | '_rank' | 'segmentId' | 'rundownId'>[]
+						}
+					},
+					reactive,
+					`partRanks_${JSON.stringify(partFilter ?? rundownRankMap.keys())}`
+				)
 
 				partRanks.forEach((part) => {
 					partRankMap.set(part._id, part)

packages/meteor-lib/src/triggers/triggersContext.ts

@@ -46,6 +46,7 @@ export interface TriggersContext {
 
 	memoizedIsolatedAutorun<TArgs extends any[], TRes>(
 		fnc: (...args: TArgs) => Promise<TRes>,
+		reactive: boolean,
 		functionName: string,
 		...params: TArgs
 	): Promise<TRes>

packages/webui/src/client/lib/memoizedIsolatedAutorun.ts

@@ -19,8 +19,6 @@ const isolatedAutorunsMem: {
  * If the `fnc` computation is invalidated, the outer computations will only be invalidated if the value returned from
  * `fnc` fails a deep equality check (_.isEqual).
  *
- * If used in server code, thie `fnc` will be run as-is, without any reactivity
- *
  * @export
  * @template T
  * @param {T} fnc The computation function to be memoized and calculated separately from the outer one.

packages/webui/src/client/lib/triggers/triggersContext.ts

@@ -39,7 +39,13 @@ export const UiTriggersContext: TriggersContext = {
 
 	doUserAction: (...args) => Tracker.nonreactive(() => doUserAction(...args)),
 
-	memoizedIsolatedAutorun,
+	memoizedIsolatedAutorun: async (fnc, reactive, functionName, ...params) => {
+		if (!reactive) {
+			return Tracker.nonreactive(() => memoizedIsolatedAutorun(fnc, functionName, ...params))
+		} else {
+			return memoizedIsolatedAutorun(fnc, functionName, ...params)
+		}
+	},
 
 	async createContextForRundownPlaylistChain(
 		_studioId: StudioId,