@sigmela/router 0.3.7 → 0.4.0

package/lib/module/RouterContext.js

@@ -1,33 +0,0 @@
-"use strict";
-
-import React, { createContext, useContext } from 'react';
-export const RouterContext = /*#__PURE__*/createContext(null);
-export const RouteLocalContext = /*#__PURE__*/createContext(null);
-export const useRouter = () => {
-  const ctx = useContext(RouterContext);
-  if (ctx == null) {
-    throw new Error('useRouter must be used within RouterContext.Provider');
-  }
-  return ctx;
-};
-export const useCurrentRoute = () => {
-  const router = useRouter();
-  const subscribe = React.useCallback(cb => router.subscribeActiveRoute(cb), [router]);
-  const get = React.useCallback(() => router.getActiveRoute(), [router]);
-  return React.useSyncExternalStore(subscribe, get, get);
-};
-export function useParams() {
-  const local = React.useContext(RouteLocalContext);
-  return local?.params ?? {};
-}
-export function useQueryParams() {
-  const local = React.useContext(RouteLocalContext);
-  return local?.query ?? {};
-}
-export function useRoute() {
-  const local = React.useContext(RouteLocalContext);
-  if (!local) {
-    throw new Error('useRoute must be used within RouterLocalContext.Provider');
-  }
-  return local;
-}

package/lib/module/ScreenStack/ScreenStack.native.js

@@ -1,3 +0,0 @@
-"use strict";
-
-export { ScreenStack } from 'react-native-screens';

package/lib/module/ScreenStack/ScreenStack.web.js

@@ -1,561 +0,0 @@
-"use strict";
-
-import { memo, useRef, useLayoutEffect, useMemo, useEffect, Children, isValidElement, Fragment, useCallback, useContext } from 'react';
-import { useTransitionMap } from 'react-transition-state';
-import { ScreenStackItemsContext, ScreenStackAnimatingContext, useScreenStackConfig } from "./ScreenStackContext.js";
-import { getPresentationTypeClass, computeAnimationType } from "./animationHelpers.js";
-import { RouterContext } from "../RouterContext.js";
-import { isModalLikePresentation } from "../types.js";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-const isScreenStackItemElement = child => {
-  if (! /*#__PURE__*/isValidElement(child)) return false;
-  const anyProps = child.props;
-  return anyProps && typeof anyProps === 'object' && 'item' in anyProps;
-};
-const getItemKey = child => {
-  const anyChild = child;
-  const reactKey = anyChild.key ?? null;
-  if (typeof reactKey === 'string' && reactKey.length > 0 && !reactKey.startsWith('.')) {
-    return reactKey;
-  }
-  const item = anyChild.props?.item;
-  if (item?.key && typeof item.key === 'string') {
-    return item.key;
-  }
-  if (item?.routeId) {
-    return String(item.routeId);
-  }
-  throw new Error('[ScreenStack] ScreenStackItem is missing a stable key');
-};
-const computeDirection = (prev, current) => {
-  if (prev.length === 0 && current.length > 0) {
-    return 'forward';
-  }
-  if (current.length > prev.length) {
-    return 'forward';
-  }
-  if (current.length < prev.length) {
-    return 'back';
-  }
-  const prevTop = prev[prev.length - 1];
-  const currentTop = current[current.length - 1];
-  if (prevTop === currentTop) {
-    return 'forward';
-  }
-  const prevIndexOfCurrentTop = prev.indexOf(currentTop);
-  const prevIndexOfPrevTop = prev.indexOf(prevTop);
-  if (prevIndexOfCurrentTop !== -1 && prevIndexOfPrevTop !== -1 && prevIndexOfCurrentTop < prevIndexOfPrevTop) {
-    return 'back';
-  }
-  return 'forward';
-};
-export const ScreenStack = /*#__PURE__*/memo(props => {
-  const {
-    children,
-    transitionTime = 250,
-    animated = true
-  } = props;
-  const router = useContext(RouterContext);
-  const debugEnabled = router?.isDebugEnabled() ?? false;
-  const devLog = useCallback((msg, data) => {
-    if (typeof __DEV__ !== 'undefined' && __DEV__ && debugEnabled) {
-      console.log(msg, data !== undefined ? JSON.stringify(data) : '');
-    }
-  }, [debugEnabled]);
-  devLog('[ScreenStack] Render', {
-    transitionTime,
-    animated,
-    childrenExists: !!children
-  });
-  const containerRef = useRef(null);
-  const isInitialMountRef = useRef(true);
-  const suppressEnterAfterEmptyRef = useRef(false);
-  const suppressedEnterKeyRef = useRef(null);
-  const isBulkRemovalRef = useRef(false);
-  const prevKeysRef = useRef([]);
-  const lastStackIdRef = useRef(null);
-  const dismissInProgressRef = useRef(false);
-  const lastDirectionRef = useRef('forward');
-  const childMapRef = useRef(new Map());
-  const stackChildren = useMemo(() => {
-    const stackItems = [];
-    Children.forEach(children, child => {
-      if (isScreenStackItemElement(child)) {
-        stackItems.push(child);
-      } else if (child != null) {
-        devLog('[ScreenStack] Non-ScreenStackItem child ignored', {
-          child
-        });
-      }
-    });
-    devLog('[ScreenStack] Parsed children', {
-      stackChildrenLength: stackItems.length
-    });
-    return stackItems;
-  }, [children, devLog]);
-  const currentStackId = useMemo(() => {
-    let found;
-    for (const child of stackChildren) {
-      const childStackId = child.props.stackId ?? child.props.item?.stackId ?? undefined;
-      if (childStackId) {
-        found = childStackId;
-        break;
-      }
-    }
-    if (found) {
-      lastStackIdRef.current = found;
-    }
-    return found ?? lastStackIdRef.current;
-  }, [stackChildren]);
-  const routeKeys = useMemo(() => {
-    const keys = stackChildren.map(child => {
-      const item = child.props.item;
-      return item?.key || getItemKey(child);
-    });
-    devLog('[ScreenStack] routeKeys', keys);
-    return keys;
-  }, [devLog, stackChildren]);
-  const childMap = useMemo(() => {
-    const map = new Map(childMapRef.current);
-    for (const child of stackChildren) {
-      const item = child.props.item;
-      const key = item?.key || getItemKey(child);
-      map.set(key, child);
-    }
-    devLog('[ScreenStack] childMap updated', {
-      size: map.size,
-      keys: Array.from(map.keys())
-    });
-    return map;
-  }, [devLog, stackChildren]);
-  useEffect(() => {
-    childMapRef.current = childMap;
-  }, [childMap]);
-  const {
-    stateMap,
-    toggle,
-    setItem,
-    deleteItem
-  } = useTransitionMap({
-    timeout: transitionTime,
-    preEnter: true,
-    mountOnEnter: true,
-    unmountOnExit: false,
-    enter: animated,
-    exit: animated,
-    allowMultiple: true,
-    onStateChange: ({
-      key,
-      current
-    }) => {
-      devLog(`[ScreenStack] Transition state change for key ${key}:`, {
-        status: current.status,
-        isMounted: current.isMounted,
-        isEnter: current.isEnter,
-        isResolved: current.isResolved
-      });
-    }
-  });
-  devLog('[ScreenStack] Current transition states:', Array.from(stateMap.entries()).map(([key, state]) => ({
-    key,
-    status: state.status,
-    isMounted: state.isMounted,
-    isEnter: state.isEnter,
-    isResolved: state.isResolved
-  })));
-  const stateMapEntries = useMemo(() => Array.from(stateMap.entries()), [stateMap]);
-  const prevKeysForDirection = prevKeysRef.current;
-  const direction = useMemo(() => {
-    const computed = computeDirection(prevKeysForDirection, routeKeys);
-    return computed;
-  }, [routeKeys, prevKeysForDirection]);
-  devLog('[ScreenStack] Computed direction', {
-    prevKeys: prevKeysRef.current,
-    routeKeys,
-    direction
-  });
-  const screenStackConfig = useScreenStackConfig();
-  const animateFirstScreenAfterEmpty = screenStackConfig.animateFirstScreenAfterEmpty ?? true;
-  const isInitialPhase = isInitialMountRef.current;
-  const keysToRender = useMemo(() => {
-    const routeKeySet = new Set(routeKeys);
-    const exitingKeys = [];
-    for (const [key, state] of stateMapEntries) {
-      if (!state.isMounted) continue;
-      if (!routeKeySet.has(key)) {
-        exitingKeys.push(key);
-      }
-    }
-    const result = [...routeKeys, ...exitingKeys];
-    devLog('[ScreenStack] Keys to render:', {
-      result,
-      exitingKeys
-    });
-    return result;
-  }, [devLog, routeKeys, stateMapEntries]);
-  const containerClassName = 'screen-stack';
-
-  // CRITICAL: Calculate bulk removal BEFORE useMemo for itemsContextValue
-  // so the flag is available when computing animation types
-  // Use prevKeysForDirection (captured before direction useMemo) to detect removals
-  const removedCount = prevKeysForDirection.filter(key => !routeKeys.includes(key)).length;
-  const isBulkRemoval = removedCount > 1 || routeKeys.length === 0 && prevKeysForDirection.length > 1;
-  isBulkRemovalRef.current = isBulkRemoval;
-  useLayoutEffect(() => {
-    devLog('[ScreenStack] === LIFECYCLE EFFECT START ===', {
-      prevKeys: prevKeysRef.current,
-      routeKeys,
-      direction
-    });
-    const routeKeySet = new Set(routeKeys);
-    const existingKeySet = new Set();
-    for (const [key] of stateMapEntries) {
-      existingKeySet.add(key);
-    }
-    const newKeys = routeKeys.filter(key => !existingKeySet.has(key));
-    const removedKeys = [...existingKeySet].filter(key => !routeKeySet.has(key));
-
-    // Track "became empty" state to suppress the next enter animation when configured.
-    // This is SplitView-secondary-only (via ScreenStackConfigContext), not global behavior.
-    if (!animateFirstScreenAfterEmpty) {
-      if (routeKeys.length === 0) {
-        suppressEnterAfterEmptyRef.current = true;
-        suppressedEnterKeyRef.current = null;
-      }
-    }
-    devLog('[ScreenStack] Lifecycle diff', {
-      newKeys,
-      removedKeys
-    });
-
-    // Bulk removal was already computed before useMemo (see above)
-    devLog('[ScreenStack] Bulk removal detected', {
-      isBulkRemoval: isBulkRemovalRef.current,
-      removedCount: removedKeys.length,
-      prevLength: prevKeysForDirection.length,
-      currentLength: routeKeys.length
-    });
-
-    // If this is the first pushed key after the stack was empty, remember its key so we can
-    // suppress only its enter animation (without affecting exit animations).
-    if (!animateFirstScreenAfterEmpty && suppressEnterAfterEmptyRef.current && routeKeys.length > 0 && newKeys.length > 0) {
-      const candidate = newKeys[newKeys.length - 1] ?? null;
-      suppressedEnterKeyRef.current = candidate;
-      suppressEnterAfterEmptyRef.current = false;
-    }
-    for (const key of newKeys) {
-      devLog(`[ScreenStack] Adding item: ${key}`);
-      setItem(key);
-      devLog(`[ScreenStack] Entering item: ${key}`);
-      toggle(key, true);
-    }
-    for (const key of removedKeys) {
-      const state = stateMap.get(key);
-      if (state && state.isEnter) {
-        devLog(`[ScreenStack] Starting exit for item: ${key}`, {
-          status: state.status
-        });
-        toggle(key, false);
-      } else {
-        devLog(`[ScreenStack] Skip exit for item (not entered or missing): ${key}`, {
-          hasState: !!state,
-          status: state?.status,
-          isEnter: state?.isEnter
-        });
-      }
-    }
-    lastDirectionRef.current = direction;
-    devLog('[ScreenStack] === LIFECYCLE EFFECT END ===');
-  }, [routeKeys, direction, prevKeysForDirection.length, setItem, toggle, stateMapEntries, stateMap, animateFirstScreenAfterEmpty, devLog]);
-  useLayoutEffect(() => {
-    devLog('[ScreenStack] === CLEANUP EFFECT START ===');
-    const routeKeySet = new Set(routeKeys);
-    for (const [key, state] of stateMapEntries) {
-      if (!state.isMounted) {
-        devLog(`[ScreenStack] Cleanup unmounted item: ${key}`, {
-          status: state.status,
-          isResolved: state.isResolved
-        });
-        deleteItem(key);
-        childMapRef.current.delete(key);
-        continue;
-      }
-      const isInStack = routeKeySet.has(key);
-      const canCleanup = !isInStack && state.status === 'exited' && state.isResolved === true;
-      if (canCleanup) {
-        devLog(`[ScreenStack] Cleanup exited item: ${key}`, {
-          status: state.status,
-          isResolved: state.isResolved
-        });
-        deleteItem(key);
-        childMapRef.current.delete(key);
-      }
-    }
-    devLog('[ScreenStack] === CLEANUP EFFECT END ===');
-  }, [routeKeys, stateMapEntries, deleteItem, devLog]);
-
-  // Update the previous keys after all layout effects so direction calculations
-  // always compare against the last committed stack.
-  useLayoutEffect(() => {
-    prevKeysRef.current = routeKeys;
-  }, [routeKeys]);
-  useEffect(() => {
-    if (!isInitialMountRef.current) return;
-    const hasMountedItem = stateMapEntries.some(([, st]) => st.isMounted);
-
-    // If the stack mounts empty, we still want the first pushed screen to animate.
-    // Mark initial mount as completed immediately in that case.
-    if (!hasMountedItem && routeKeys.length === 0) {
-      if (animateFirstScreenAfterEmpty) {
-        isInitialMountRef.current = false;
-        devLog('[ScreenStack] Initial mount completed (empty stack)');
-      }
-      return;
-    }
-    if (hasMountedItem) {
-      isInitialMountRef.current = false;
-      devLog('[ScreenStack] Initial mount completed');
-    }
-  }, [stateMapEntries, routeKeys.length, animateFirstScreenAfterEmpty, devLog]);
-
-  // Clear suppression key once it is no longer the top screen (so it can animate normally as
-  // a background when new screens are pushed).
-  useLayoutEffect(() => {
-    if (animateFirstScreenAfterEmpty) return;
-    const topKey = routeKeys[routeKeys.length - 1] ?? null;
-    if (!topKey) {
-      suppressedEnterKeyRef.current = null;
-      return;
-    }
-    if (suppressedEnterKeyRef.current && suppressedEnterKeyRef.current !== topKey) {
-      suppressedEnterKeyRef.current = null;
-    }
-  }, [routeKeys, animateFirstScreenAfterEmpty]);
-  useEffect(() => {
-    if (!debugEnabled) return;
-    if (!containerRef.current) return;
-    const items = containerRef.current.querySelectorAll('.screen-stack-item');
-    if (items.length === 0) return;
-    devLog('[ScreenStack] DOM State after render:', {
-      containerClasses: containerRef.current.className,
-      containerDataAnimation: containerRef.current.dataset.animation,
-      containerDataDirection: containerRef.current.dataset.direction,
-      itemCount: items.length
-    });
-  }, [debugEnabled, devLog]);
-  const topKey = routeKeys[routeKeys.length - 1] ?? null;
-  const routeKeySet = useMemo(() => new Set(routeKeys), [routeKeys]);
-  const hasExitingItems = useMemo(() => {
-    return stateMapEntries.some(([key, state]) => state.isMounted && !routeKeySet.has(key));
-  }, [stateMapEntries, routeKeySet]);
-  const hasExitingModalLike = useMemo(() => {
-    return stateMapEntries.some(([key, state]) => {
-      if (!state.isMounted || routeKeySet.has(key)) return false;
-      const item = childMap.get(key)?.props.item;
-      return isModalLikePresentation(item?.options?.stackPresentation);
-    });
-  }, [childMap, routeKeySet, stateMapEntries]);
-
-  // D4: Compute active modal/sheet state for data attributes
-  const hasActiveModal = useMemo(() => {
-    for (const key of routeKeys) {
-      const child = childMap.get(key);
-      if (!child) continue;
-      const presentation = child.props.item?.options?.stackPresentation;
-      if (presentation && presentation !== 'push' && presentation !== 'formSheet' && presentation !== 'pageSheet' && presentation !== 'sheet' && isModalLikePresentation(presentation)) {
-        return true;
-      }
-    }
-    return false;
-  }, [routeKeys, childMap]);
-  const hasActiveSheet = useMemo(() => {
-    for (const key of routeKeys) {
-      const child = childMap.get(key);
-      if (!child) continue;
-      const presentation = child.props.item?.options?.stackPresentation;
-      if (presentation === 'formSheet' || presentation === 'pageSheet' || presentation === 'sheet') {
-        return true;
-      }
-    }
-    return false;
-  }, [routeKeys, childMap]);
-
-  // D5: Scroll lock during active modal (ref-counted for nested stacks)
-  useEffect(() => {
-    if (!hasActiveModal) return;
-    const g = globalThis;
-    g.__scrollLockCount = (g.__scrollLockCount ?? 0) + 1;
-    if (g.__scrollLockCount === 1) {
-      g.__scrollLockPrev = document.body.style.overflow;
-      document.body.style.overflow = 'hidden';
-    }
-    return () => {
-      g.__scrollLockCount = Math.max(0, (g.__scrollLockCount ?? 1) - 1);
-      if (g.__scrollLockCount === 0) {
-        document.body.style.overflow = g.__scrollLockPrev ?? '';
-      }
-    };
-  }, [hasActiveModal]);
-  const animationDirection = hasExitingItems ? lastDirectionRef.current : direction;
-  const stackDismissedByRouter = router?.isStackBeingDismissed?.(currentStackId ?? undefined) ?? false;
-  if (stackDismissedByRouter) {
-    dismissInProgressRef.current = true;
-  }
-  const isStackBeingDismissed = dismissInProgressRef.current;
-  devLog('[ScreenStack] Dismiss state', {
-    stackId: currentStackId,
-    isStackBeingDismissed
-  });
-  useLayoutEffect(() => {
-    if (!isStackBeingDismissed) return;
-    if (hasExitingItems) return;
-    dismissInProgressRef.current = false;
-    router?.clearStackDismissed?.(currentStackId ?? undefined);
-  }, [hasExitingItems, isStackBeingDismissed, currentStackId, router]);
-  const itemsContextValue = useMemo(() => {
-    const items = {};
-    for (let index = 0; index < keysToRender.length; index++) {
-      const key = keysToRender[index];
-      if (!key) continue;
-      const transitionState = stateMap.get(key);
-      const child = childMap.get(key);
-      if (!child) continue;
-      const item = child.props.item;
-      if (!item) continue;
-      const presentation = item.options?.stackPresentation ?? 'push';
-      const animated = item.options?.animated ?? true;
-      const isInStack = routeKeySet.has(key);
-      const isTop = isInStack && topKey !== null && key === topKey;
-      let phase;
-      if (!isInStack) {
-        phase = 'exiting';
-      } else if (isTop) {
-        phase = 'active';
-      } else {
-        phase = 'inactive';
-      }
-      const rawStatus = transitionState?.status || 'preEnter';
-      const status = isInitialPhase && (rawStatus === 'preEnter' || rawStatus === 'entering') ? 'entered' : rawStatus;
-      const routeIndex = routeKeys.indexOf(key);
-      const zIndex = routeIndex >= 0 ? routeIndex + 1 : keysToRender.length + index + 1;
-      const presentationType = getPresentationTypeClass(presentation);
-      let animationType = computeAnimationType(key, isInStack, isTop, animationDirection, presentation, isInitialPhase, animated, isBulkRemovalRef.current);
-      if (hasExitingModalLike && isTop && isInStack) {
-        animationType = 'none';
-      }
-      if (isStackBeingDismissed && !isInStack) {
-        animationType = 'no-animate';
-      }
-
-      // SplitView-secondary-only: suppress enter animation for the first screen after empty.
-      if (!animateFirstScreenAfterEmpty && isTop && direction === 'forward' && suppressedEnterKeyRef.current === key) {
-        animationType = 'none';
-      }
-      items[key] = {
-        presentationType,
-        animationType,
-        phase,
-        transitionStatus: status,
-        zIndex
-      };
-    }
-    for (let index = 0; index < routeKeys.length; index++) {
-      const key = routeKeys[index];
-      if (!key || items[key]) continue;
-      const child = childMap.get(key);
-      if (!child) continue;
-      const item = child.props.item;
-      if (!item) continue;
-      const presentation = item.options?.stackPresentation ?? 'push';
-      const animated = item.options?.animated ?? true;
-      const isInStack = routeKeySet.has(key);
-      const isTop = isInStack && topKey !== null && key === topKey;
-      let phase;
-      if (isTop) {
-        phase = 'active';
-      } else {
-        phase = 'inactive';
-      }
-      const presentationType = getPresentationTypeClass(presentation);
-      let animationType = isInitialPhase ? 'none' : computeAnimationType(key, isInStack, isTop, animationDirection, presentation, isInitialPhase, animated, isBulkRemovalRef.current);
-      if (hasExitingModalLike && isTop && isInStack) {
-        animationType = 'none';
-      }
-      if (isStackBeingDismissed && !isInStack) {
-        animationType = 'no-animate';
-      }
-      if (!animateFirstScreenAfterEmpty && isTop && direction === 'forward' && suppressedEnterKeyRef.current === key) {
-        animationType = 'none';
-      }
-      items[key] = {
-        presentationType,
-        animationType,
-        phase,
-        transitionStatus: 'preEnter',
-        zIndex: index + 1
-      };
-    }
-    return {
-      items
-    };
-  }, [keysToRender, stateMap, childMap, routeKeySet, topKey, isInitialPhase, routeKeys, animationDirection, direction, animateFirstScreenAfterEmpty, isStackBeingDismissed, hasExitingModalLike]);
-  const animating = useMemo(() => {
-    return stateMapEntries.some(([, state]) => state.isMounted && (state.status === 'entering' || state.status === 'exiting' || state.status === 'preEnter' || state.status === 'preExit'));
-  }, [stateMapEntries]);
-
-  // D6: Compute current screen label for accessibility
-  const currentScreenLabel = useMemo(() => {
-    if (!topKey) return '';
-    const child = childMap.get(topKey);
-    if (!child) return '';
-    const item = child.props.item;
-    return item?.routeId || topKey;
-  }, [topKey, childMap]);
-  return /*#__PURE__*/_jsx(ScreenStackItemsContext.Provider, {
-    value: itemsContextValue,
-    children: /*#__PURE__*/_jsx(ScreenStackAnimatingContext.Provider, {
-      value: animating,
-      children: /*#__PURE__*/_jsxs("div", {
-        ref: containerRef,
-        className: containerClassName + (animating ? ' animating' : ''),
-        "data-has-active-modal": hasActiveModal ? 'true' : undefined,
-        "data-has-active-sheet": hasActiveSheet ? 'true' : undefined,
-        "data-animation": animating ? 'true' : undefined,
-        style: {
-          '--stack-transition-time': `${transitionTime}ms`
-        },
-        children: [/*#__PURE__*/_jsx("div", {
-          "aria-live": "polite",
-          role: "status",
-          style: {
-            position: 'absolute',
-            width: 1,
-            height: 1,
-            overflow: 'hidden',
-            clip: 'rect(0,0,0,0)'
-          },
-          children: currentScreenLabel
-        }), keysToRender.map(key => {
-          const transitionState = stateMap.get(key);
-          if (!transitionState || !transitionState.isMounted) {
-            devLog(`[ScreenStack] Skipping ${key} - no state or not mounted`, {
-              hasState: !!transitionState,
-              isMounted: transitionState?.isMounted
-            });
-            return null;
-          }
-          const child = childMap.get(key);
-          if (!child) {
-            devLog(`[ScreenStack] No child element for ${key}`, {
-              availableKeys: Array.from(childMap.keys())
-            });
-            return null;
-          }
-          return /*#__PURE__*/_jsx(Fragment, {
-            children: child
-          }, child.key || key);
-        })]
-      })
-    })
-  });
-});

package/lib/module/ScreenStack/ScreenStackContext.js

@@ -1,21 +0,0 @@
-"use strict";
-
-import { createContext, useContext } from 'react';
-export const ScreenStackItemsContext = /*#__PURE__*/createContext(null);
-export const ScreenStackAnimatingContext = /*#__PURE__*/createContext(false);
-export const ScreenStackConfigContext = /*#__PURE__*/createContext({
-  animateFirstScreenAfterEmpty: true
-});
-export const useScreenStackConfig = () => {
-  return useContext(ScreenStackConfigContext);
-};
-export const useScreenStackItemsContext = () => {
-  const ctx = useContext(ScreenStackItemsContext);
-  if (!ctx) {
-    throw new Error('useScreenStackItemsContext must be used within ScreenStack');
-  }
-  return ctx;
-};
-export const useScreenStackAnimatingContext = () => {
-  return useContext(ScreenStackAnimatingContext);
-};