react-native-screen-transitions 4.0.0-alpha.2 → 4.0.0-alpha.4

package/src/providers/screen/descriptors/descriptors.provider.tsx

@@ -1,10 +1,12 @@
 import type { ReactNode } from "react";
 import { useMemo } from "react";
+import { useScreenTransitionsAdapterOptionalContext } from "../../../adapters/with-screen-transitions/context";
+import { useBlankStackStore } from "../../../providers/stack/blank-stack.provider";
 import type { BaseStackDescriptor } from "../../../types/stack.types";
 import createProvider from "../../../utils/create-provider";
 import type { DescriptorDerivations } from "./helpers/derive-descriptor-derivations";
 import { deriveDescriptorDerivations } from "./helpers/derive-descriptor-derivations";
-import { getAncestorKeyState } from "./helpers/get-ancestor-keys";
+import { getAncestorKeys } from "./helpers/get-ancestor-keys";
 
 /**
  * Base descriptor interface - minimal contract for all stack types.
@@ -25,87 +27,89 @@ export type DescriptorDerivationsContextValue = DescriptorDerivations;
 
 interface DescriptorStoreValue<
 	TDescriptor extends BaseDescriptor = BaseDescriptor,
-> {
+> extends DescriptorsContextValue<TDescriptor> {
 	descriptors: DescriptorsContextValue<TDescriptor>;
 	derivations: DescriptorDerivationsContextValue;
+	options: TDescriptor["options"];
 }
 
-interface DescriptorsProviderProps<TDescriptor extends BaseDescriptor> {
+type DescriptorsProviderProps = {
 	children: ReactNode;
-	previous?: TDescriptor;
-	current: TDescriptor;
-	next?: TDescriptor;
-}
-
-const {
-	DescriptorsProvider: InternalDescriptorsProvider,
-	useDescriptorsStore,
-} = createProvider("Descriptors", { guarded: true })<
-	DescriptorsProviderProps<BaseDescriptor>,
-	DescriptorStoreValue<BaseDescriptor>
->(({ previous, current, next, children }) => {
-	const descriptors = useMemo(
-		() => ({ previous, current, next }),
-		[previous, current, next],
-	);
-
-	const { ancestorKeys, ancestorDestinationPairKey } = useMemo(
-		() => getAncestorKeyState(current),
-		[current],
-	);
+	previous?: BaseDescriptor;
+	current?: BaseDescriptor;
+	next?: BaseDescriptor;
+	routeKey?: string;
+};
 
-	const derivations = useMemo(
-		() =>
-			deriveDescriptorDerivations({
-				previous,
-				current,
-				next,
-				ancestorKeys,
-				ancestorDestinationPairKey,
-			}),
-		[previous, current, next, ancestorKeys, ancestorDestinationPairKey],
-	);
+export const { DescriptorsProvider, useDescriptorsStore } = createProvider(
+	"Descriptors",
+	{ guarded: true },
+)<DescriptorsProviderProps, DescriptorStoreValue<BaseDescriptor>>(
+	({ previous, current, next, routeKey, children }) => {
+		const blankStackCurrent = useBlankStackStore((store) =>
+			routeKey ? store?.scenesByKey[routeKey]?.descriptor : undefined,
+		);
+		const blankStackPrevious = useBlankStackStore((store) =>
+			routeKey ? store?.scenesByKey[routeKey]?.previousDescriptor : undefined,
+		);
+		const blankStackNext = useBlankStackStore((store) =>
+			routeKey ? store?.scenesByKey[routeKey]?.nextDescriptor : undefined,
+		);
+		const adapterContext = useScreenTransitionsAdapterOptionalContext();
+		const adapterScene = routeKey
+			? (adapterContext?.scenesByKey?.[routeKey] ??
+				adapterContext?.scenes[
+					adapterContext.routeIndexByKey.get(routeKey) ?? -1
+				])
+			: undefined;
 
-	const value = useMemo(
-		() => ({
-			descriptors,
-			derivations,
-		}),
-		[descriptors, derivations],
-	);
+		const resolvedCurrent =
+			current ?? blankStackCurrent ?? adapterScene?.descriptor;
+		const resolvedPrevious =
+			previous ?? blankStackPrevious ?? adapterScene?.previousDescriptor;
+		const resolvedNext = next ?? blankStackNext ?? adapterScene?.nextDescriptor;
 
-	return {
-		value,
-		children,
-	};
-});
+		if (!resolvedCurrent) {
+			throw new Error(
+				`Descriptors scene "${routeKey ?? "unknown"}" was not found.`,
+			);
+		}
 
-export function DescriptorsProvider<TDescriptor extends BaseDescriptor>({
-	children,
-	previous,
-	current,
-	next,
-}: DescriptorsProviderProps<TDescriptor>) {
-	const providerProps = {
-		previous,
-		current,
-		next,
-		children,
-	};
+		const descriptors = useMemo(
+			() => ({
+				previous: resolvedPrevious,
+				current: resolvedCurrent,
+				next: resolvedNext,
+			}),
+			[resolvedPrevious, resolvedCurrent, resolvedNext],
+		);
 
-	return <InternalDescriptorsProvider {...providerProps} />;
-}
+		const ancestorKeys = useMemo(
+			() => getAncestorKeys(resolvedCurrent),
+			[resolvedCurrent],
+		);
 
-export function useDescriptors<
-	TDescriptor extends BaseDescriptor = BaseDescriptor,
->() {
-	return useDescriptorsStore(
-		(store) => store.descriptors,
-	) as DescriptorsContextValue<TDescriptor>;
-}
-
-export function useDescriptorDerivations(): DescriptorDerivationsContextValue {
-	return useDescriptorsStore((store) => store.derivations);
-}
+		const derivations = useMemo(
+			() =>
+				deriveDescriptorDerivations({
+					previous: resolvedPrevious,
+					current: resolvedCurrent,
+					next: resolvedNext,
+					ancestorKeys,
+				}),
+			[resolvedPrevious, resolvedCurrent, resolvedNext, ancestorKeys],
+		);
 
-export { useDescriptorsStore };
+		return {
+			value: {
+				previous: resolvedPrevious,
+				current: resolvedCurrent,
+				next: resolvedNext,
+				descriptors,
+				derivations,
+				options: resolvedCurrent.options,
+			},
+			children,
+		};
+	},
+);

package/src/providers/screen/descriptors/helpers/derive-descriptor-derivations.ts

@@ -8,7 +8,6 @@ export interface DescriptorDerivations {
 	nextScreenKey?: string;
 	sourcePairKey?: ScreenPairKey;
 	destinationPairKey?: ScreenPairKey;
-	ancestorDestinationPairKey?: ScreenPairKey;
 	parentScreenKey?: string;
 	isFirstKey: boolean;
 	isTopMostScreen: boolean;
@@ -21,7 +20,6 @@ interface Params {
 	current: BaseStackDescriptor;
 	next?: BaseStackDescriptor;
 	ancestorKeys: string[];
-	ancestorDestinationPairKey?: ScreenPairKey;
 }
 
 export function deriveDescriptorDerivations({
@@ -29,7 +27,6 @@ export function deriveDescriptorDerivations({
 	current,
 	next,
 	ancestorKeys,
-	ancestorDestinationPairKey,
 }: Params): DescriptorDerivations {
 	const previousScreenKey = previous?.route.key;
 	const currentScreenKey = current.route.key;
@@ -56,7 +53,6 @@ export function deriveDescriptorDerivations({
 		nextScreenKey,
 		sourcePairKey,
 		destinationPairKey,
-		ancestorDestinationPairKey,
 		parentScreenKey: ancestorKeys[0],
 		isFirstKey,
 		isTopMostScreen,

package/src/providers/screen/descriptors/helpers/get-ancestor-keys.ts

@@ -1,26 +1,14 @@
-import { createScreenPairKey } from "../../../../stores/bounds/helpers/link-pairs.helpers";
-import type { ScreenPairKey } from "../../../../stores/bounds/types";
 import type { BaseStackDescriptor } from "../../../../types/stack.types";
 
-export interface AncestorKeyState {
-	ancestorKeys: string[];
-	ancestorDestinationPairKey?: ScreenPairKey;
-}
-
 /**
  * Builds nested navigator ancestor keys from immediate parent to root.
- * The nearest ancestor destination pair lets child routes attach measurements
- * to the transition owned by the parent stack.
  */
-export function getAncestorKeyState(
-	current: BaseStackDescriptor,
-): AncestorKeyState {
+export function getAncestorKeys(current: BaseStackDescriptor): string[] {
 	const ancestors: string[] = [];
-	let ancestorDestinationPairKey: ScreenPairKey | undefined;
 	const nav = current.navigation as any;
 
 	if (typeof nav?.getParent !== "function") {
-		return { ancestorKeys: ancestors };
+		return ancestors;
 	}
 
 	let parent = nav.getParent();
@@ -31,25 +19,10 @@ export function getAncestorKeyState(
 			const focusedRoute = state.routes[state.index];
 			if (focusedRoute?.key) {
 				ancestors.push(focusedRoute.key);
-
-				const previousRoute = state.routes[state.index - 1];
-				if (!ancestorDestinationPairKey && previousRoute?.key) {
-					ancestorDestinationPairKey = createScreenPairKey(
-						previousRoute.key,
-						focusedRoute.key,
-					);
-				}
 			}
 		}
 		parent = parent.getParent();
 	}
 
-	return {
-		ancestorKeys: ancestors,
-		ancestorDestinationPairKey,
-	};
-}
-
-export function getAncestorKeys(current: BaseStackDescriptor): string[] {
-	return getAncestorKeyState(current).ancestorKeys;
+	return ancestors;
 }

package/src/providers/screen/descriptors/index.tsx

@@ -1,7 +1,5 @@
 export {
 	type BaseDescriptor,
 	DescriptorsProvider,
-	useDescriptorDerivations,
-	useDescriptors,
 	useDescriptorsStore,
 } from "./descriptors.provider";

package/src/providers/screen/gestures/gestures.provider.tsx

@@ -3,7 +3,7 @@ import { Gesture } from "react-native-gesture-handler";
 import { useSharedValue } from "react-native-reanimated";
 import { ScrollStore } from "../../../stores/scroll.store";
 import createProvider from "../../../utils/create-provider";
-import { useDescriptorDerivations } from "../descriptors";
+import { useDescriptorsStore } from "../descriptors";
 import { useScreenGestureConfig } from "./hooks/use-screen-gesture-config";
 import { useWalkUpAndRegisterShadowingClaims } from "./ownership/use-walk-up-and-register-shadowing-claims";
 import { useBuildPanGesture } from "./pan/use-build-pan-gesture";
@@ -19,74 +19,83 @@ interface ScreenGestureProviderProps {
 	children: React.ReactNode;
 }
 
-export const {
-	ScreenGestureProvider,
-	useScreenGestureContext: useGestureContext,
-} = createProvider("ScreenGesture", { guarded: false })<
-	ScreenGestureProviderProps,
-	GestureContextType
->(({ children }): { value: GestureContextType; children: React.ReactNode } => {
-	const gestureContext = useGestureContext();
-	const gestureConfig = useScreenGestureConfig();
-	const { currentScreenKey } = useDescriptorDerivations();
+export const { ScreenGestureProvider, useScreenGestureStore: useGestureStore } =
+	createProvider("ScreenGesture", { guarded: false })<
+		ScreenGestureProviderProps,
+		GestureContextType
+	>(
+		(
+			{ children },
+			{ useParentStore },
+		): { value: GestureContextType; children: React.ReactNode } => {
+			const gestureContext = useParentStore();
+			const gestureConfig = useScreenGestureConfig();
+			const currentScreenKey = useDescriptorsStore(
+				(store) => store.derivations.currentScreenKey,
+			);
 
-	const scrollState = ScrollStore.getValue(currentScreenKey, "coordination");
+			const scrollState = ScrollStore.getValue(
+				currentScreenKey,
+				"coordination",
+			);
 
-	// Ancestors read this before activating. If a nested screen claims the same
-	// direction, it writes here so the ancestor can fail and let it take priority.
-	const childDirectionClaims =
-		useSharedValue<DirectionClaimMap>(NO_DIRECTION_CLAIMS);
+			// Ancestors read this before activating. If a nested screen claims the same
+			// direction, it writes here so the ancestor can fail and let it take priority.
+			const childDirectionClaims =
+				useSharedValue<DirectionClaimMap>(NO_DIRECTION_CLAIMS);
 
-	// The first gesture to activate owns navigation release. Other gestures may
-	// still join as companion trackers during the same simultaneous composition.
-	const gestureCompositionOwner = useSharedValue<GestureCompositionOwner>(null);
+			// The first gesture to activate owns navigation release. Other gestures may
+			// still join as companion trackers during the same simultaneous composition.
+			const gestureCompositionOwner =
+				useSharedValue<GestureCompositionOwner>(null);
 
-	const panGesture = useBuildPanGesture({
-		scrollState,
-		gestureConfig,
-		childDirectionClaims,
-		gestureCompositionOwner,
-	});
+			const panGesture = useBuildPanGesture({
+				scrollState,
+				gestureConfig,
+				childDirectionClaims,
+				gestureCompositionOwner,
+			});
 
-	const pinchGesture = useBuildPinchGesture({
-		gestureConfig,
-		gestureCompositionOwner,
-	});
+			const pinchGesture = useBuildPinchGesture({
+				gestureConfig,
+				gestureCompositionOwner,
+			});
 
-	const detectorGesture = useMemo(
-		() => Gesture.Simultaneous(panGesture, pinchGesture),
-		[panGesture, pinchGesture],
-	);
+			const detectorGesture = useMemo(
+				() => Gesture.Simultaneous(panGesture, pinchGesture),
+				[panGesture, pinchGesture],
+			);
 
-	const value = useMemo<GestureContextType>(
-		() => ({
-			routeKey: currentScreenKey,
-			detectorGesture,
-			panGesture,
-			pinchGesture,
-			scrollState,
-			gestureContext,
-			claimedDirections: gestureConfig.participation.claimedDirections,
-			childDirectionClaims,
-		}),
-		[
-			currentScreenKey,
-			detectorGesture,
-			panGesture,
-			pinchGesture,
-			scrollState,
-			gestureContext,
-			gestureConfig.participation.claimedDirections,
-			childDirectionClaims,
-		],
-	);
+			const value = useMemo<GestureContextType>(
+				() => ({
+					routeKey: currentScreenKey,
+					detectorGesture,
+					panGesture,
+					pinchGesture,
+					scrollState,
+					gestureContext,
+					claimedDirections: gestureConfig.participation.claimedDirections,
+					childDirectionClaims,
+				}),
+				[
+					currentScreenKey,
+					detectorGesture,
+					panGesture,
+					pinchGesture,
+					scrollState,
+					gestureContext,
+					gestureConfig.participation.claimedDirections,
+					childDirectionClaims,
+				],
+			);
 
-	useWalkUpAndRegisterShadowingClaims(
-		gestureConfig.participation.claimedDirections,
-	);
+			useWalkUpAndRegisterShadowingClaims(
+				gestureConfig.participation.claimedDirections,
+			);
 
-	return {
-		value,
-		children,
-	};
-});
+			return {
+				value,
+				children,
+			};
+		},
+	);

package/src/providers/screen/gestures/hooks/use-screen-gesture-config.ts

@@ -1,16 +1,15 @@
 import { useMemo } from "react";
-import { useDescriptorDerivations, useDescriptors } from "../../descriptors";
-import { useGestureContext } from "../gestures.provider";
+import { useDescriptorsStore } from "../../descriptors";
+import { useGestureStore } from "../gestures.provider";
 import { resolveScreenGestureConfig } from "../shared/policy";
 import type { ScreenGestureConfig } from "../types";
 
 export function useScreenGestureConfig(): ScreenGestureConfig {
-	const gestureContext = useGestureContext();
-	const {
-		current: { options },
-	} = useDescriptors();
-
-	const { isFirstKey } = useDescriptorDerivations();
+	const gestureContext = useGestureStore();
+	const options = useDescriptorsStore((store) => store.options);
+	const isFirstKey = useDescriptorsStore(
+		(store) => store.derivations.isFirstKey,
+	);
 
 	return useMemo(
 		() =>

package/src/providers/screen/gestures/hooks/use-screen-gesture.ts

@@ -2,7 +2,7 @@ import {
 	type ChainTarget,
 	resolveChainTarget,
 } from "../../../../utils/resolve-chain-target";
-import { useGestureContext } from "../gestures.provider";
+import { useGestureStore } from "../gestures.provider";
 import { walkGestureAncestors } from "../shared/ancestors";
 
 export type ScreenGestureTarget = ChainTarget;
@@ -21,7 +21,7 @@ export type ScreenGestureTarget = ChainTarget;
  * ```
  */
 export const useScreenGesture = (target?: ScreenGestureTarget) => {
-	const ctx = useGestureContext();
+	const ctx = useGestureStore();
 
 	return (
 		resolveChainTarget({

package/src/providers/screen/gestures/hooks/use-stable-runtime-config.ts

@@ -3,7 +3,7 @@ import { type SharedValue, useSharedValue } from "react-native-reanimated";
 import { AnimationStore } from "../../../../stores/animation.store";
 import { GestureStore } from "../../../../stores/gesture.store";
 import { SystemStore } from "../../../../stores/system.store";
-import { useDescriptorDerivations } from "../../descriptors";
+import { useDescriptorsStore } from "../../descriptors";
 import type { GesturePolicy, GestureRuntime } from "../types";
 
 type RuntimeConfigInput<TPolicy extends GesturePolicy> = Omit<
@@ -14,7 +14,9 @@ type RuntimeConfigInput<TPolicy extends GesturePolicy> = Omit<
 export function useStableRuntimeConfig<TPolicy extends GesturePolicy>(
 	runtimeConfigInput: RuntimeConfigInput<TPolicy>,
 ): SharedValue<GestureRuntime<TPolicy>> {
-	const { currentScreenKey } = useDescriptorDerivations();
+	const currentScreenKey = useDescriptorsStore(
+		(store) => store.derivations.currentScreenKey,
+	);
 	const { participation, policy } = runtimeConfigInput;
 
 	const stores = useMemo(() => {

package/src/providers/screen/gestures/index.tsx

@@ -1,6 +1,6 @@
 export {
 	ScreenGestureProvider,
-	useGestureContext,
+	useGestureStore,
 } from "./gestures.provider";
 export type {
 	DirectionClaim,

package/src/providers/screen/gestures/ownership/shadowing-claims.ts

@@ -1,16 +1,15 @@
 import type { ClaimedDirections } from "../../../../types/ownership.types";
-import type { StackSceneActivity } from "../../../../types/stack.types";
 
 export const resolveShadowingClaimDirections = ({
-	currentActivity,
+	isCurrentScreenClosing,
 	currentClaimedDirections,
 	previousClaimedDirections,
 }: {
-	currentActivity: StackSceneActivity | undefined;
+	isCurrentScreenClosing: boolean;
 	currentClaimedDirections: ClaimedDirections;
 	previousClaimedDirections: ClaimedDirections;
 }): ClaimedDirections => {
-	if (currentActivity === "closing") {
+	if (isCurrentScreenClosing) {
 		return previousClaimedDirections;
 	}
 

package/src/providers/screen/gestures/ownership/use-walk-up-and-register-shadowing-claims.ts

@@ -8,10 +8,10 @@ import {
 } from "../../../../types/ownership.types";
 import {
 	type BaseDescriptor,
-	useDescriptorDerivations,
-	useDescriptors,
+	useDescriptorsStore,
 } from "../../../screen/descriptors";
-import { useGestureContext } from "../gestures.provider";
+import { useBlankStackStore } from "../../../stack/blank-stack.provider";
+import { useGestureStore } from "../gestures.provider";
 import { walkGestureAncestors } from "../shared/ancestors";
 import { resolveScreenGestureConfig } from "../shared/policy";
 import type { GestureContextType } from "../types";
@@ -135,9 +135,17 @@ const getDescriptorClaimedDirections = (
 export function useWalkUpAndRegisterShadowingClaims(
 	claimedDirections: ClaimedDirections,
 ): void {
-	const parentContext = useGestureContext();
-	const { current, previous } = useDescriptors();
-	const { isTopMostScreen, currentScreenKey } = useDescriptorDerivations();
+	const parentContext = useGestureStore();
+	const previous = useDescriptorsStore((store) => store.previous);
+	const isTopMostScreen = useDescriptorsStore(
+		(store) => store.derivations.isTopMostScreen,
+	);
+	const currentScreenKey = useDescriptorsStore(
+		(store) => store.derivations.currentScreenKey,
+	);
+	const isCurrentScreenClosing = useBlankStackStore(
+		(store) => store?.scenesByKey[currentScreenKey]?.activity === "closing",
+	);
 
 	/*
 	 * We want to calculate effective claimed directions as claimedDirections is not enough for us.
@@ -161,14 +169,14 @@ export function useWalkUpAndRegisterShadowingClaims(
 	const effectiveClaimedDirections = useMemo(
 		() =>
 			resolveShadowingClaimDirections({
-				currentActivity: current.activity,
+				isCurrentScreenClosing,
 				currentClaimedDirections: claimedDirections,
 				previousClaimedDirections: getDescriptorClaimedDirections(
 					previous,
 					parentContext,
 				),
 			}),
-		[current.activity, claimedDirections, previous, parentContext],
+		[isCurrentScreenClosing, claimedDirections, previous, parentContext],
 	);
 
 	const shadowedAncestors = useMemo(

package/src/providers/screen/gestures/pan/activation/use-pan-activation.ts

@@ -7,7 +7,7 @@ import { type SharedValue, useSharedValue } from "react-native-reanimated";
 import { GestureStore } from "../../../../../stores/gesture.store";
 import { GestureActivationState } from "../../../../../types/gesture.types";
 import type { Direction } from "../../../../../types/ownership.types";
-import { useDescriptorDerivations } from "../../../descriptors";
+import { useDescriptorsStore } from "../../../descriptors";
 import type { ScreenOptionsContextValue } from "../../../options";
 import { resolvePanRuntime } from "../../shared/runtime";
 import type {
@@ -36,7 +36,12 @@ export const usePanActivation = ({
 	dimensions,
 	gestureCompositionOwner,
 }: UsePanActivationProps) => {
-	const { currentScreenKey, parentScreenKey } = useDescriptorDerivations();
+	const currentScreenKey = useDescriptorsStore(
+		(store) => store.derivations.currentScreenKey,
+	);
+	const parentScreenKey = useDescriptorsStore(
+		(store) => store.derivations.parentScreenKey,
+	);
 
 	const ancestorDismissing = useMemo(() => {
 		if (!parentScreenKey) return null;

package/src/providers/screen/gestures/pan/behavior/pan-lifecycle.ts

@@ -1,8 +1,8 @@
 import { clamp, type SharedValue } from "react-native-reanimated";
 import { scheduleOnRN } from "react-native-worklets";
-import { EPSILON, FALSE, TRUE } from "../../../../../constants";
+import { EPSILON, TRUE } from "../../../../../constants";
+import { emitMotionStart } from "../../../../../stores/animation.store";
 import { animateToProgress } from "../../../../../utils/animation/animate-to-progress";
-import { emit } from "../../../../../utils/animation/emit";
 import {
 	normalizeGestureTranslation,
 	resolveGestureVelocity,
@@ -30,16 +30,7 @@ export const startPanBase = (runtime: PanGestureRuntime) => {
 		stores: { gestures, animations },
 	} = runtime;
 
-	const wasSettling = gestures.settling.get();
-	const hasResidualGesture =
-		Math.abs(gestures.normX.get()) > EPSILON ||
-		Math.abs(gestures.normY.get()) > EPSILON ||
-		Math.abs(gestures.normScale.get()) > EPSILON ||
-		Math.abs(gestures.rotation.get()) > EPSILON;
-
-	if (!wasSettling || !hasResidualGesture) {
-		emit(animations.willAnimate, TRUE, FALSE);
-	}
+	emitMotionStart(animations);
 
 	gestures.dragging.set(TRUE);
 	gestures.dismissing.set(0);
@@ -134,6 +125,9 @@ export const finalizePanRelease = (
 		system.targetProgress.set(plan.commitProgress);
 	}
 
+	const progressAlreadyAtTarget =
+		Math.abs(animations.transitionProgress.get() - plan.target) <= EPSILON;
+
 	if (canDriveRelease && plan.shouldDismiss) {
 		snapshotGestureHandoff(gestures, {
 			velocity: plan.handoffVelocity,
@@ -143,6 +137,8 @@ export const finalizePanRelease = (
 	resetPanGestureValues({
 		plan,
 		gestures,
+		animations,
+		completeMotion: !plan.shouldDismiss && progressAlreadyAtTarget,
 		updateLifecycle: canDriveRelease,
 	});
 
@@ -150,12 +146,8 @@ export const finalizePanRelease = (
 		return;
 	}
 
-	const progressAlreadyAtTarget =
-		Math.abs(animations.transitionProgress.get() - plan.target) <= EPSILON;
-
 	if (!plan.shouldDismiss && progressAlreadyAtTarget) {
 		system.targetProgress.set(plan.target);
-		animations.progressAnimating.set(FALSE);
 		return;
 	}