narraleaf-react 1.1.0 → 1.1.1

package/dist/game/nlcore/action/actions/videoAction.d.ts

@@ -20,6 +20,16 @@ export declare class VideoAction<T extends Values<typeof VideoActionTypes> = Val
         readonly seek: "video:seek";
     };
     executeAction(gameState: GameState, injection: ActionExecutionInjection): Awaitable<CalledActionResult>;
+    /**
+     * A transport row - pause, resume, seek, stop - aimed at a clip that is no longer on the stage.
+     *
+     * There is nothing to talk to, and nothing it could have done: a clip that has left has stopped,
+     * and the next show puts it back from the start. Which side of the clip leaving such a row lands
+     * on is not always the author's to decide - a clip played without waiting for it leaves when it
+     * ends, at a moment set by how fast the player reads - so a row that would have worked a click
+     * earlier must not stop the story a click later. The same answer `hide` gives.
+     */
+    private skipOffStage;
     private changeStateBase;
     /**
      * {@link changeStateBase} for a fade, which the player can walk away from halfway.

package/dist/game/player/gameState.d.ts

@@ -133,6 +133,14 @@ export type PlayerStateData = {
              * { [layerName]: [displayableId][] }
              */
             layers: Record<string, string[]>;
+            /**
+             * The ids of the clips this scene put on the stage. Their state is in
+             * {@link PlayerStateData.videos}; this says which scene each one leaves with.
+             *
+             * Written only when the scene has any. Absent in saves written before clips belonged to
+             * scenes, and a clip no scene names is given to the scene the story is running in.
+             */
+            videos?: string[];
         };
     }[];
     audio: AudioManagerDataRaw;
@@ -156,6 +164,14 @@ export type PlayerStateElementSnapshot = {
      * scene that is on the stage and one that is on the stage waiting for a call to return.
      */
     suspended?: boolean;
+    /**
+     * The clips this scene had on the stage, each with its state, in stage order.
+     *
+     * A clip is drawn over the scene rather than inside one of its layers, but it belongs to the
+     * scene that put it there all the same, and leaves with it. Absent in snapshots taken before
+     * clips belonged to scenes; read as none.
+     */
+    videos?: [Video, VideoStateRaw][];
 };
 export type PlayerAction = CalledActionResult;
 interface StageUtils {
@@ -210,6 +226,16 @@ export declare class GameState {
      * See {@link VideoWarmQueue}.
      */
     private readonly videoWarmQueue;
+    /**
+     * Which scene each of the story's clips belongs to: the one running when the clip went on.
+     *
+     * A clip is not on one of the scene's layers - it is a sibling of the scene's root, so that a clip
+     * the preloader warmed can be taken over without being remounted - so nothing about where it sits
+     * says whose it is. And it has to be somebody's, because a scene takes everything it put on the
+     * stage with it when it leaves. Kept beside {@link PlayerState.videos} rather than in it, because
+     * the stage order of clips is not grouped by scene.
+     */
+    private videoOwners;
     private videoMissingReporter;
     /** Sources already reported as unwarmed, so one clip in a loop does not report every pass. */
     private readonly reportedUnwarmedVideos;
@@ -547,6 +573,21 @@ export declare class GameState {
      * excluded explicitly rather than by trusting that route to stay closed.
      */
     private resetLayers;
+    /**
+     * The clip half of leaving a scene: every clip the scene put on the stage leaves with it, and
+     * goes back to its authored state, exactly as the sprites on its layers do in
+     * {@link resetLayers}.
+     *
+     * Without this a clip outlived its scene, and since a clip paints over its scene's sprites, one
+     * that stopped on its last frame covered the whole of the next scene - where nothing could take it
+     * down, because a host that names stage objects per scene cannot even name it.
+     *
+     * Every path that takes a scene off the stage comes through here - a plain jump's exit, a call
+     * returning, a jump giving up the callers parked behind it, stepping back over a scene's entrance
+     * - and each of them snapshots the scene first (see {@link createElementSnapshot}), so the clips
+     * come back with it when the step is undone.
+     */
+    private releaseVideosOf;
     private syncNvlDerivedState;
     private emitNvlStateChange;
     private resolveNvlAdvance;