Refactor jump code

Author: FelixHenninger

packages/library/src/base/controller.ts

@@ -168,21 +168,28 @@ export class Controller<C extends Component = Component> extends Emitter {
           }
         }
 
-        // Rerun that stack
-        if (commonStack.length == 0) {
+        this.context = await this.iterator?.tempSplice(commonStack.length + 1, [
+          {}, // flipData
+          this.context,
+        ])
+
+        // Having torn down the larger part of the current component stack,
+        // issue a reset to the remaining part.
+        //@ts-ignore
+        await last(this.currentStack)?._reset?.()
+
+        // Don't re-mount the root component
+        if (this.currentStack.length > 1) {
           //@ts-ignore
-          await this.root?._reset?.()
-        } else {
-          await commonStack.at(-1)?._reset?.()
+          this.iterator?.restartLeaf()
         }
-        await this.iterator?.reset(commonStack.length)
+
+        // The fastforward call will also trigger continue
         await this.jump('fastforward', {
           target: data.targetStack,
           spliceLevel: commonStack.length,
         })
 
-        // Continue removed as it moves on too quickly
-        //await this.continue(this.currentLeaf, {})
         break
       default:
         console.error(`Unknown jump instruction ${instruction}`)

packages/library/src/base/util/iterators/flipIterable.ts

@@ -1,4 +1,4 @@
-import { range } from 'lodash'
+import { last, range } from 'lodash'
 
 import { Component, Status } from '../../component'
 import { requestAnimationFrameMaybe } from '../rAF'
@@ -47,6 +47,7 @@ export interface FlipIterator<T>
   // with the remainder of the interface.
   fastForward: (targetStack: String[], spliceLevel?: number) => Promise<void>
   peek: () => stackSummary
+  tempSplice: (level: number, input: IteratorInput) => Promise<any>
 }
 
 export class FlipIterable {
@@ -76,6 +77,7 @@ export class FlipIterable {
     const sliceIterator = this.timelineIterable[Symbol.asyncIterator]()
     let currentStack: Component[] = []
     let lockPromises: Promise<any>[] = []
+    let restartLeaf = false
 
     return {
       initialize: async () => {
@@ -112,23 +114,21 @@ export class FlipIterable {
           // the current and future stacks
           ;({ incoming, outgoing } = resolveFlip(currentStack, nextStack))
 
-          // End all outgoing components, starting from the leaf
-          for (const c of [...outgoing].reverse()) {
-            try {
-              c.internals.emitter.off(
-                EventName.endUncontrolled,
-                triggerContinue,
-              )
-              currentStack.pop()
-              cancelled.push(c)
-              await c.end(flipData.reason, { ...flipData, controlled: true })
-              context = c.leaveContext(context)
-            } catch (error) {
-              console.error(`Error ending`, c)
-              throw error
-            }
+          if (restartLeaf && currentStack.length > 0) {
+            //@ts-ignore
+            incoming.unshift(currentStack.pop())
+            restartLeaf = false
           }
 
+          // End all outgoing components, starting from the leaf
+          context = await stopOutgoing(
+            outgoing,
+            currentStack,
+            cancelled,
+            flipData,
+            context,
+          )
+
           // Start all incoming components, starting from the top of the stack
           for (const c of incoming) {
             try {
@@ -193,6 +193,34 @@ export class FlipIterable {
           },
         }
       },
+      tempSplice: async (
+        level: number,
+        [flipData, context]: [any, object] = [{}, {}],
+      ) => {
+        const oldStack = currentStack
+        const newStack = currentStack.slice(0, level)
+
+        // There are no incoming components in this flip
+        const { outgoing } = resolveFlip(oldStack, newStack)
+
+        // Stop outgoing components
+        const newContext = await stopOutgoing(
+          outgoing,
+          currentStack,
+          [],
+          flipData,
+          context,
+        )
+
+        // Reset nested slice iterator
+        sliceIterator.splice(level)
+
+        return newContext
+      },
+      //@ts-ignore
+      restartLeaf: () => {
+        restartLeaf = true
+      },
       splice: sliceIterator.splice,
       findSplice: sliceIterator.findSplice,
       reset: sliceIterator.reset,
@@ -228,3 +256,25 @@ export class FlipIterable {
     }
   }
 }
+
+const stopOutgoing = async function (
+  outgoing: Component[],
+  currentStack: Component[],
+  cancelled: Component[],
+  flipData: any,
+  context: object,
+) {
+  for (const c of [...outgoing].reverse()) {
+    try {
+      c.internals.emitter.off(EventName.endUncontrolled, triggerContinue)
+      currentStack.pop()
+      cancelled.push(c)
+      await c.end(flipData.reason, { ...flipData, controlled: true })
+      context = c.leaveContext(context)
+    } catch (error) {
+      console.error(`Error ending`, c)
+      throw error
+    }
+  }
+  return context
+}

packages/library/src/base/util/iterators/timeline.ts

@@ -88,7 +88,7 @@ export class SliceIterable<T extends Object> {
             //@ts-ignore
             if (value.status >= Status.running) {
               //@ts-ignore
-              value._reset()
+              await value?._reset?.()
             }
             if (this.#checkIterator(value)) {
               outputStack.push(value)