ember-nav-stack 6.1.2 → 7.1.0

package/README.md

@@ -1,43 +1,187 @@
 # ember-nav-stack
 
-This addon is used by Yapp to blend mobile-style stack navigation with Ember routing. It draws heavy inspiration from ember-elsewhere.
+iOS-style stack navigation for Ember. Routes push and pop horizontally across one or more visual layers, with spring-driven animations and an interactive back-swipe gesture. Inspired by [ember-elsewhere](https://github.com/ef4/ember-elsewhere).
 
-This addon's current status is "opensource, but unpolished". It lacks tests, docs, and other niceties of a well-maintained Ember addon.
+## Compatibility
 
-Compatibility
-------------------------------------------------------------------------------
+- **ember-source**: `>= 4.12.0` (declared as a peer dependency)
+- **Node**: `>= 20.19`
+- **ember-cli**: any version compatible with the host app
 
-* Ember.js v3.24 or above
-* Ember CLI v3.24 or above
-* Node.js v12 or above
+## Installation
 
+```
+ember install ember-nav-stack
+```
 
-Installation
-------------------------------------------------------------------------------
+Then import the addon's stylesheet from your app's entry point:
 
+```js
+// app/app.js
+import 'ember-nav-stack/styles/nav-stack.css';
 ```
-ember install ember-nav-stack
+
+(Or `@import 'ember-nav-stack/styles/nav-stack.css';` from your top-level CSS.) Unlike the pre-v6 versions of this addon, v6+ ships as a [v2 addon](https://github.com/embroider-build/embroider/blob/main/docs/v2-addon-format.md) and does not auto-merge styles into your build.
+
+## Concepts
+
+The addon revolves around three pieces:
+
+- **`NavStacksService`** (`nav-stacks`) — a shared store of stack contents keyed by layer index. Items are pushed and popped via `<ToNavStack>` (most consumers never call the service directly).
+- **`<NavStack>`** — renders one visual stack: the current item, the previous-item header, the spring animations between stack states, and the back-swipe gesture.
+- **`<ToNavStack>`** — declarative push. Mounting one adds an item to the stack at the given layer; unmounting removes it.
+
+A typical app renders one `<NavStack>` per layer index (often just one for the base layer, with modal/overlay layers as needed) and uses `<ToNavStack>` from inside each route's template to declare the route's content as a stack item.
+
+## Two patterns: ad-hoc components vs. routed pages
+
+### 1. Ad-hoc `<NavStack>` + `<ToNavStack>` directly
+
+Use this when the stack content isn't tied to routes — e.g. a modal flow inside a single page, a multi-step form.
+
+```hbs
+{{!-- app/templates/application.hbs --}}
+<div style="width:320px;height:480px;position:relative">
+  <NavStack @layer={{0}} @back={{this.handleBack}} />
+</div>
+
+<ToNavStack
+  @layer={{0}}
+  @item={{component "my-first-step" model=this.model}}
+  @header={{component "my-first-step/header" model=this.model}}
+/>
+
+{{#if this.isAtSecondStep}}
+  <ToNavStack
+    @layer={{0}}
+    @item={{component "my-second-step" model=this.model}}
+    @header={{component "my-second-step/header" model=this.model}}
+  />
+{{/if}}
+```
+
+Each `<ToNavStack>` describes one stack item — its body (`@item`) and its header (`@header`) as curried components. Mounting more `<ToNavStack>` instances pushes them onto the stack in mount order; unmounting them pops.
+
+### 2. `StackableRoute` for route-driven stacks
+
+When your stack maps to routes (one stack item per route in a parent → child → grandchild URL), extend `StackableRoute` and rely on the convention:
+
+```js
+// app/routes/page.js
+import StackableRoute from 'ember-nav-stack/routes/stackable-route';
+
+export default class PageRoute extends StackableRoute {
+  // Optionally:
+  //   templateName       — the route's template name; defaults to 'stackable'
+  //                        which auto-renders <ToNavStack> for this route
+  //   newLayer = true    — this route is on a new visual layer (e.g. a modal
+  //                        stack above the base navigation)
+  //   routableTemplateName — override the routing-component name (see below)
+}
 ```
 
+`StackableRoute` does three things for you:
+
+1. **`templateName = 'stackable'`** by default. The shipped `stackable` template renders `<ToNavStack @layer={{this.layerIndex}} @item={{component this.routeComponent ...}} @header={{component this.headerComponent ...}} />` plus `{{outlet}}`, so you don't write that boilerplate per route.
+2. **Computes `layerIndex`** by walking up the route tree (via the public `RouterService.currentRoute` / `activeTransition.to` chain). Routes that opt into a new layer with `newLayer = true` get parent's `layerIndex + 1`.
+3. **Provides a `back` action** that transitions to the parent route. Wire it to your back button via `{{on "click" (route-action "back")}}` (or your preferred action-delivery mechanism).
+
+### The `routable-components/...` convention
+
+`StackableRoute` derives the component names for `@item` and `@header` from the route's name:
 
-Usage
-------------------------------------------------------------------------------
+| Route name | `routeComponent` (item) | `headerComponent` |
+|---|---|---|
+| `page` | `routable-components/page` | `routable-components/page/header` |
+| `yapp.page.schedule-item` | `routable-components/yapp/page/schedule-item` | `routable-components/yapp/page/schedule-item/header` |
 
-[Longer description of how to use the addon in apps.]
+So a route called `page` resolves to component `routable-components/page` (i.e. `app/components/routable-components/page.{js,hbs}` in classic layout, or whatever your resolver does for that name). Headers live at `<route-component-name>/header`.
 
-Testing
-------------------------------------------------------------------------------
+Override per-route via `routableTemplateName = 'something-else'` if a single component should back multiple routes.
 
-`ember-nav-stack` registers waiters for stack recomputes and transition animations. Ember's built-in test helpers such as `visit` and `click` wait for these operations automatically, so downstream apps should not need custom "nav stack idle" helpers or manual `waitFor` calls.
+## `<NavStack>` arguments
 
+| Arg | Required | Description |
+|---|---|---|
+| `@layer` | yes | Integer ≥ 0. Identifies which layer this NavStack renders. Items pushed via `<ToNavStack @layer={{n}}>` appear here when `n === @layer`. |
+| `@back` | no | Callback invoked when a back-swipe completes successfully. Typically wired via `{{route-action "back"}}` when using `StackableRoute`. Without this, the back-swipe gesture is disabled. |
+| `@footer` | no | A curried component to render below the stack (e.g. a tab bar). Often only set on layer 0. |
+| `@birdsEyeDebugging` | no | If truthy, applies an `.is-birdsEyeDebugging` class for a debug view that shows all layers at once. |
+| `@extractComponentKey` | no | Override how `NavStack` derives a stable identity for a stack item's component (used to detect "did the root component change?" → cut vs. slide). The default reads the curried component's resolved name + bound `model.id`. Most apps don't need to override. |
+| `@onActiveItemChange` | no | Callback invoked whenever the top of the stack changes identity (push, pop, root swap, initial render). Receives `{ isInitialRender, previousDepth, currentDepth, previousTopKey, currentTopKey }`, where the `*TopKey` values are the top stack item's component name. Use this — not subclassing — to react to navigation (e.g. moving keyboard focus to the newly active heading, recording analytics page views). |
+
+## `<ToNavStack>` arguments
+
+| Arg | Required | Description |
+|---|---|---|
+| `@layer` | yes | Integer ≥ 0. Which `<NavStack>` should receive this item. |
+| `@item` | yes | A curried component (`{{component 'my-page' model=this.model}}`) rendered as the stack item's body. |
+| `@header` | no | A curried component rendered in the stack item's header slot. Receives `@model`, `@controller`, and `@back` as arguments when the parent `<NavStack>` has them. |
+
+## Animation behavior
+
+`NavStack` chooses one of these transitions automatically based on observed stack state:
+
+| Situation | Animation |
+|---|---|
+| First render of the stack | `cut` (no animation, snap into place) |
+| Layer > 0 appearing from empty | `slideUp` (slides up from below) |
+| Layer > 0 disappearing to empty | `slideDown` (slides down off-screen) |
+| Same root, deeper push | `slideForward` (new page slides in from the right) |
+| Same root, shallower pop | `slideBack` (current page slides off to the right) |
+| Root component changed | `cut` (instant swap — used for tab switches) |
+
+The decision is made by `decideTransition` (`src/utils/transition-decision.js`), which you can unit-test in isolation if you're forking or debugging. See its source comment for the full truth table.
+
+## Disabling animation (e.g. for tests)
+
+```js
+// config/environment.js
+ENV['ember-nav-stack'] = { suppressAnimation: true };
+```
+
+When set, `<NavStack>` skips its springs and snaps directly to the post-transition position. Useful in test environments that don't need to wait on rAF-driven animations.
+
+## Test waiters
+
+`ember-nav-stack` registers waiters for stack recomputes, transition animations, and the initial render so Ember's built-in test helpers (`visit`, `click`, `settled`, etc.) wait correctly. **You should not need custom "wait for nav stack idle" helpers or manual `waitFor` calls** when navigation is your only async source.
+
+If you do need a programmatic hook:
+
+```js
+import { getOwner } from '@ember/application';
+
+let navStacks = getOwner(this).lookup('service:nav-stacks');
+await navStacks.waitUntilTransitionIdle();
+```
+
+## CSS classes you can target
+
+The addon owns these class names. Consumers can style them (or query them in tests) but should not rely on internal structure:
+
+- `.NavStack` — the stack container element
+- `.NavStack--layer0`, `.NavStack--layer1`, … — added per layer index
+- `.NavStack--withFooter` — added when `@footer` is set
+- `.NavStack-item`, `.NavStack-item-0`, `.NavStack-item-1`, … — per-item containers
+- `.NavStack-itemContainer` — the horizontally-translated container that holds items
+- `.NavStack-header` — wrapper for the current + parent header
+- `.NavStack-currentHeaderContainer`, `.NavStack-parentItemHeaderContainer` — the two live header slots
+- `.NavStack-footer` — wrapper for `@footer`
+
+`.NavStack-gestureBackTargetHeader` may briefly appear during a completed back-swipe; it's an overlay clone that gets cleaned up automatically.
+
+## Test support
+
+```js
+import { isInViewport, getElementInViewportRatio } from 'ember-nav-stack/test-support';
+```
 
-Contributing
-------------------------------------------------------------------------------
+Two helpers for asserting on the visible position of stack items in tests. See `src/test-support/in-viewport.js` for details.
 
-See the [Contributing](CONTRIBUTING.md) guide for details.
+## Contributing
 
+See [CONTRIBUTING.md](CONTRIBUTING.md) for setup and development notes.
 
-License
-------------------------------------------------------------------------------
+## License
 
 This project is licensed under the [MIT License](LICENSE.md).

package/addon-main.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+const { addonV1Shim } = require('@embroider/addon-shim');
+module.exports = addonV1Shim(__dirname);

package/dist/_app_/components/nav-stack-inner-wrapper.js

@@ -0,0 +1 @@
+export { default } from "ember-nav-stack/components/nav-stack-inner-wrapper";

package/dist/_app_/components/nav-stack.js

@@ -0,0 +1 @@
+export { default } from "ember-nav-stack/components/nav-stack";

package/dist/_app_/components/to-nav-stack.js

@@ -0,0 +1 @@
+export { default } from "ember-nav-stack/components/to-nav-stack";

package/dist/_app_/helpers/nav-layer-indices.js

@@ -0,0 +1 @@
+export { default } from "ember-nav-stack/helpers/nav-layer-indices";

package/dist/_app_/modifiers/back-swipe.js

@@ -0,0 +1 @@
+export { default } from "ember-nav-stack/modifiers/back-swipe";

package/dist/_app_/services/gesture.js

@@ -0,0 +1 @@
+export { default } from "ember-nav-stack/services/gesture";

package/dist/_app_/services/nav-stacks.js

@@ -0,0 +1 @@
+export { default } from "ember-nav-stack/services/nav-stacks";

package/dist/_app_/templates/stackable.js

@@ -0,0 +1 @@
+export { default } from "ember-nav-stack/templates/stackable";

package/dist/back-swipe-gesture.js

@@ -0,0 +1,261 @@
+import Hammer from 'hammerjs';
+import { run } from '@ember/runloop';
+import { Spring } from 'wobble';
+import { macroCondition, isTesting } from '@embroider/macros';
+import BackSwipeRecognizer from './utils/back-swipe-recognizer.js';
+import { setTransform } from './utils/animation.js';
+import { currentTransitionPercentage, styleHeaderElements, HEADER_PARALLAX_OFFSET } from './utils/header-style.js';
+
+// Spring configuration for the swipe-driven horizontal animation. Tuned to
+// match the programmatic spring used by `NavStack#horizontalTransition`.
+const SWIPE_SPRING_CONFIG = {
+  stiffness: 1000,
+  damping: 500,
+  mass: 3
+};
+
+// Encapsulates the back-swipe gesture state and behavior. NavStack
+// instantiates one of these in its `did-insert` callback and tears it down
+// on `will-destroy`. The gesture owns:
+//
+//   - The Hammer.js manager + BackSwipeRecognizer
+//   - The pan handler context (element refs, startingX, backX, thresholdX)
+//   - The swipe-driven Spring (cancellation, onUpdate, onStop)
+//   - The target-header overlay snapshot used to bridge the re-render gap
+//     after a completed back-swipe (see PR #79 for the bug fix)
+//   - Registration with the gesture service for cross-component recognizer
+//     ordering (preferRecognizer / stopPreferringRecognizer)
+//
+// NavStack communicates with the gesture via three callbacks supplied at
+// construction time:
+//
+//   getCanNavigateBack() → boolean
+//     Returns whether back navigation is currently allowed (typically
+//     `stackDepth > 1` and `args.back` defined). Re-evaluated on every
+//     `setupContext()` call so the gesture stays in sync with stack changes.
+//
+//   onBack()
+//     Invoked when a back-swipe completes successfully. Wraps the
+//     consumer's `@back` callback.
+//
+//   onBackSwipeOverlay(clone)
+//     Invoked with the cloned target-header element immediately before
+//     `onBack`. NavStack stores the clone so its `handleStackDepthChange`
+//     can schedule cleanup once the stack pop actually lands (see the
+//     gesture-back overlay machinery in PR #79).
+//
+// NavStack drives the gesture's pan-recognizer state during programmatic
+// transitions via `disablePan()` (called from `transitionDidBegin`) and
+// `setupContext()` (called from `transitionDidEnd` to re-grab DOM refs and
+// re-enable the recognizer once the animation completes).
+class BackSwipeGesture {
+  constructor({
+    element,
+    navStacksService,
+    gestureService,
+    getCanNavigateBack,
+    onBack,
+    onBackSwipeOverlay
+  }) {
+    this.element = element;
+    this.navStacksService = navStacksService;
+    this.gestureService = gestureService;
+    this.getCanNavigateBack = getCanNavigateBack;
+    this.onBack = onBack;
+    this.onBackSwipeOverlay = onBackSwipeOverlay;
+    this.hammer = new Hammer.Manager(element, {
+      inputClass: Hammer.TouchMouseInput,
+      recognizers: [[BackSwipeRecognizer]]
+    });
+    this.setupContext();
+    this.hammer.on('pan', this._handlePanEvent);
+    this.gestureService.register(this, this.hammer.get('pan'));
+  }
+  teardown() {
+    if (this.hammer) {
+      this.gestureService.unregister(this, this.hammer.get('pan'));
+      this.hammer.off('pan');
+      this.hammer.destroy();
+      this.hammer = null;
+    }
+    // If a swipe completed and produced an overlay but the consumer hasn't
+    // claimed it via `onBackSwipeOverlay` yet (or we're being destroyed in
+    // mid-stride), drop it so it doesn't leak into the DOM.
+    if (this._unclaimedOverlay?.parentNode) {
+      this._unclaimedOverlay.parentNode.removeChild(this._unclaimedOverlay);
+    }
+    this._unclaimedOverlay = null;
+  }
+
+  // Called by NavStack when a programmatic transition starts. Disables the
+  // pan recognizer so a new swipe can't start while the animation is
+  // running. A swipe-driven spring that's already in flight is left to
+  // complete on its own — the programmatic transition's spring tracks its
+  // active spring separately (NavStack#_horizontalSpring) and cancels any
+  // prior horizontal spring before starting.
+  disablePan() {
+    this.hammer?.get('pan').set({
+      enable: false
+    });
+  }
+
+  // Called by NavStack after a programmatic transition completes (and also
+  // by the constructor for initial wiring). Re-grabs DOM refs (item width
+  // may have changed), recomputes startingX/backX/thresholdX, and
+  // re-enables the recognizer.
+  setupContext() {
+    this.containerElement = this.element.querySelector('.NavStack-itemContainer');
+    this.currentHeaderElement = this.element.querySelector('.NavStack-currentHeaderContainer');
+    this.parentHeaderElement = this.element.querySelector('.NavStack-parentItemHeaderContainer');
+    this.startingX = this._getX(this.containerElement);
+    let currentStackItemElement = this.element.querySelector('.NavStack-item:last-child');
+    if (!currentStackItemElement) {
+      this.canNavigateBack = false;
+      return;
+    }
+    let itemWidth = currentStackItemElement.getBoundingClientRect().width;
+    this.backX = this.startingX + itemWidth;
+    this.thresholdX = itemWidth / 2;
+    this.canNavigateBack = this.getCanNavigateBack();
+    this.hammer?.get('pan').set({
+      enable: true,
+      threshold: 9
+    });
+  }
+
+  // Called by the gesture service when another gesture-aware component
+  // registers — we must require its pan recognizer to fail before ours can
+  // succeed (or vice versa). Matches the public surface the service
+  // expects on registered objects.
+  preferRecognizer(recognizer) {
+    this.hammer?.get('pan').requireFailure(recognizer);
+  }
+  stopPreferringRecognizer(recognizer) {
+    this.hammer?.get('pan').dropRequireFailure(recognizer);
+  }
+  _handlePanEvent = ev => {
+    if (this._activeSpring) {
+      return;
+    }
+    // Clamp the gesture's effective displacement at 0 so it can never travel
+    // left of its starting position. Without this, sliding the finger past
+    // origin produces a negative `deltaX`, and `currentTransitionPercentage`
+    // — which takes Math.abs of the delta — interprets it as forward
+    // progress: parent header fades in and current header fades out as if a
+    // forward transition were under way, the opposite of the back-swipe the
+    // user actually started. Clamping makes the gesture latch at origin
+    // until the finger crosses back rightward.
+    let effectiveDeltaX = Math.max(0, ev.deltaX);
+    setTransform(this.containerElement, `translateX(${this.startingX + effectiveDeltaX}px)`);
+    let ratio = currentTransitionPercentage(this.startingX, this.backX, this.startingX + effectiveDeltaX);
+    styleHeaderElements(ratio, true, this.currentHeaderElement, this.parentHeaderElement);
+    if (this.currentHeaderElement) {
+      this.currentHeaderElement.style.opacity = ratio;
+    }
+    if (this.parentHeaderElement) {
+      this.parentHeaderElement.style.opacity = 1 - ratio;
+    }
+    if (ev.isFinal) {
+      this._handlePanEnd(ev);
+    }
+  };
+  _handlePanEnd(ev) {
+    let effectiveDeltaX = Math.max(0, ev.deltaX);
+    let shouldNavigateBack = this._adjustX(ev.center.x) >= this.thresholdX && this.canNavigateBack;
+    let initialVelocity = ev.velocityX;
+    let fromValue = this.startingX + effectiveDeltaX;
+    let toValue = shouldNavigateBack ? this.backX : this.startingX;
+    this.navStacksService.notifyTransitionStart();
+    let finalize = () => {
+      if (shouldNavigateBack) {
+        // The cross-fade ended with parentHeaderElement (target page header)
+        // visible. onBack() will eventually re-render the live header
+        // containers, swapping content: currentHeaderContainer becomes the
+        // target page's header. Snapshot the visible target header into an
+        // overlay clone so it stays on screen across that re-render.
+        // Cleanup is owned by the parent NavStack and runs once the stack
+        // pop actually lands (see PR #79 for the full lifecycle).
+        let overlay = this._cloneTargetHeaderOverlay();
+        if (this.currentHeaderElement) {
+          this.currentHeaderElement.style.opacity = 0;
+          setTransform(this.currentHeaderElement, `translateX(${HEADER_PARALLAX_OFFSET}px)`);
+        }
+        if (this.parentHeaderElement) {
+          this.parentHeaderElement.style.opacity = 0;
+          setTransform(this.parentHeaderElement, `translateX(${-HEADER_PARALLAX_OFFSET}px)`);
+        }
+        this.navStacksService.notifyTransitionEnd();
+        this._activeSpring = null;
+        this._unclaimedOverlay = overlay;
+        this.onBackSwipeOverlay?.(overlay);
+        this._unclaimedOverlay = null;
+        run(this.onBack);
+      } else {
+        setTransform(this.containerElement, `translateX(${this.startingX}px)`);
+        if (this.currentHeaderElement) {
+          this.currentHeaderElement.style.opacity = 1;
+          setTransform(this.currentHeaderElement, 'translateX(0px)');
+        }
+        if (this.parentHeaderElement) {
+          this.parentHeaderElement.style.opacity = 0;
+          setTransform(this.parentHeaderElement, `translateX(${-HEADER_PARALLAX_OFFSET}px)`);
+        }
+        this.navStacksService.notifyTransitionEnd();
+        this._activeSpring = null;
+      }
+    };
+    if (fromValue === toValue && initialVelocity === 0) {
+      finalize();
+      return;
+    }
+    let spring = new Spring({
+      initialVelocity,
+      fromValue,
+      toValue,
+      ...SWIPE_SPRING_CONFIG
+    });
+    this._activeSpring = spring;
+    spring.onUpdate(s => {
+      setTransform(this.containerElement, `translateX(${s.currentValue}px)`);
+      styleHeaderElements(currentTransitionPercentage(this.startingX, this.backX, s.currentValue), false, this.parentHeaderElement, this.currentHeaderElement);
+      // If the spring's momentum carries it past the back-threshold after
+      // the user released below the threshold, retarget to backX so the
+      // animation completes the back-swipe rather than snapping back.
+      if (!shouldNavigateBack && s.currentValue >= this.startingX + this.thresholdX) {
+        shouldNavigateBack = true;
+        spring.updateConfig({
+          toValue: this.backX
+        });
+      }
+    }).onStop(() => finalize()).start();
+  }
+  _cloneTargetHeaderOverlay() {
+    let liveParent = this.element.querySelector('.NavStack-parentItemHeaderContainer');
+    if (!liveParent) {
+      return null;
+    }
+    let clone = liveParent.cloneNode(true);
+    clone.classList.remove('NavStack-parentItemHeaderContainer');
+    clone.classList.add('NavStack-gestureBackTargetHeader');
+    clone.style.opacity = '1';
+    setTransform(clone, 'translateX(0px)');
+    // Append last so it paints on top of currentHeaderContainer.
+    this.element.querySelector('.NavStack-header').appendChild(clone);
+    return clone;
+  }
+  _getX(element) {
+    return this._adjustX(element.getBoundingClientRect().left);
+  }
+  _adjustX(x) {
+    if (macroCondition(isTesting())) {
+      let testingEl = document.querySelector('#ember-testing');
+      if (testingEl) {
+        return x - testingEl.getBoundingClientRect().left;
+      }
+    }
+    return x;
+  }
+}
+
+export { BackSwipeGesture as default };
+//# sourceMappingURL=back-swipe-gesture.js.map

package/dist/back-swipe-gesture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"back-swipe-gesture.js","sources":["../src/back-swipe-gesture.js"],"sourcesContent":["import Hammer from 'hammerjs';\nimport { run } from '@ember/runloop';\nimport { Spring } from 'wobble';\nimport { macroCondition, isTesting } from '@embroider/macros';\nimport BackSwipeRecognizer from './utils/back-swipe-recognizer.js';\nimport { setTransform } from './utils/animation.js';\nimport {\n  HEADER_PARALLAX_OFFSET,\n  currentTransitionPercentage,\n  styleHeaderElements,\n} from './utils/header-style.js';\n\n// Spring configuration for the swipe-driven horizontal animation. Tuned to\n// match the programmatic spring used by `NavStack#horizontalTransition`.\nconst SWIPE_SPRING_CONFIG = {\n  stiffness: 1000,\n  damping: 500,\n  mass: 3,\n};\n\n// Encapsulates the back-swipe gesture state and behavior. NavStack\n// instantiates one of these in its `did-insert` callback and tears it down\n// on `will-destroy`. The gesture owns:\n//\n//   - The Hammer.js manager + BackSwipeRecognizer\n//   - The pan handler context (element refs, startingX, backX, thresholdX)\n//   - The swipe-driven Spring (cancellation, onUpdate, onStop)\n//   - The target-header overlay snapshot used to bridge the re-render gap\n//     after a completed back-swipe (see PR #79 for the bug fix)\n//   - Registration with the gesture service for cross-component recognizer\n//     ordering (preferRecognizer / stopPreferringRecognizer)\n//\n// NavStack communicates with the gesture via three callbacks supplied at\n// construction time:\n//\n//   getCanNavigateBack() → boolean\n//     Returns whether back navigation is currently allowed (typically\n//     `stackDepth > 1` and `args.back` defined). Re-evaluated on every\n//     `setupContext()` call so the gesture stays in sync with stack changes.\n//\n//   onBack()\n//     Invoked when a back-swipe completes successfully. Wraps the\n//     consumer's `@back` callback.\n//\n//   onBackSwipeOverlay(clone)\n//     Invoked with the cloned target-header element immediately before\n//     `onBack`. NavStack stores the clone so its `handleStackDepthChange`\n//     can schedule cleanup once the stack pop actually lands (see the\n//     gesture-back overlay machinery in PR #79).\n//\n// NavStack drives the gesture's pan-recognizer state during programmatic\n// transitions via `disablePan()` (called from `transitionDidBegin`) and\n// `setupContext()` (called from `transitionDidEnd` to re-grab DOM refs and\n// re-enable the recognizer once the animation completes).\nexport default class BackSwipeGesture {\n  constructor({\n    element,\n    navStacksService,\n    gestureService,\n    getCanNavigateBack,\n    onBack,\n    onBackSwipeOverlay,\n  }) {\n    this.element = element;\n    this.navStacksService = navStacksService;\n    this.gestureService = gestureService;\n    this.getCanNavigateBack = getCanNavigateBack;\n    this.onBack = onBack;\n    this.onBackSwipeOverlay = onBackSwipeOverlay;\n\n    this.hammer = new Hammer.Manager(element, {\n      inputClass: Hammer.TouchMouseInput,\n      recognizers: [[BackSwipeRecognizer]],\n    });\n    this.setupContext();\n    this.hammer.on('pan', this._handlePanEvent);\n    this.gestureService.register(this, this.hammer.get('pan'));\n  }\n\n  teardown() {\n    if (this.hammer) {\n      this.gestureService.unregister(this, this.hammer.get('pan'));\n      this.hammer.off('pan');\n      this.hammer.destroy();\n      this.hammer = null;\n    }\n    // If a swipe completed and produced an overlay but the consumer hasn't\n    // claimed it via `onBackSwipeOverlay` yet (or we're being destroyed in\n    // mid-stride), drop it so it doesn't leak into the DOM.\n    if (this._unclaimedOverlay?.parentNode) {\n      this._unclaimedOverlay.parentNode.removeChild(this._unclaimedOverlay);\n    }\n    this._unclaimedOverlay = null;\n  }\n\n  // Called by NavStack when a programmatic transition starts. Disables the\n  // pan recognizer so a new swipe can't start while the animation is\n  // running. A swipe-driven spring that's already in flight is left to\n  // complete on its own — the programmatic transition's spring tracks its\n  // active spring separately (NavStack#_horizontalSpring) and cancels any\n  // prior horizontal spring before starting.\n  disablePan() {\n    this.hammer?.get('pan').set({ enable: false });\n  }\n\n  // Called by NavStack after a programmatic transition completes (and also\n  // by the constructor for initial wiring). Re-grabs DOM refs (item width\n  // may have changed), recomputes startingX/backX/thresholdX, and\n  // re-enables the recognizer.\n  setupContext() {\n    this.containerElement = this.element.querySelector(\n      '.NavStack-itemContainer',\n    );\n    this.currentHeaderElement = this.element.querySelector(\n      '.NavStack-currentHeaderContainer',\n    );\n    this.parentHeaderElement = this.element.querySelector(\n      '.NavStack-parentItemHeaderContainer',\n    );\n    this.startingX = this._getX(this.containerElement);\n    let currentStackItemElement = this.element.querySelector(\n      '.NavStack-item:last-child',\n    );\n    if (!currentStackItemElement) {\n      this.canNavigateBack = false;\n      return;\n    }\n    let itemWidth = currentStackItemElement.getBoundingClientRect().width;\n    this.backX = this.startingX + itemWidth;\n    this.thresholdX = itemWidth / 2;\n    this.canNavigateBack = this.getCanNavigateBack();\n    this.hammer?.get('pan').set({ enable: true, threshold: 9 });\n  }\n\n  // Called by the gesture service when another gesture-aware component\n  // registers — we must require its pan recognizer to fail before ours can\n  // succeed (or vice versa). Matches the public surface the service\n  // expects on registered objects.\n  preferRecognizer(recognizer) {\n    this.hammer?.get('pan').requireFailure(recognizer);\n  }\n\n  stopPreferringRecognizer(recognizer) {\n    this.hammer?.get('pan').dropRequireFailure(recognizer);\n  }\n\n  _handlePanEvent = (ev) => {\n    if (this._activeSpring) {\n      return;\n    }\n    // Clamp the gesture's effective displacement at 0 so it can never travel\n    // left of its starting position. Without this, sliding the finger past\n    // origin produces a negative `deltaX`, and `currentTransitionPercentage`\n    // — which takes Math.abs of the delta — interprets it as forward\n    // progress: parent header fades in and current header fades out as if a\n    // forward transition were under way, the opposite of the back-swipe the\n    // user actually started. Clamping makes the gesture latch at origin\n    // until the finger crosses back rightward.\n    let effectiveDeltaX = Math.max(0, ev.deltaX);\n    setTransform(\n      this.containerElement,\n      `translateX(${this.startingX + effectiveDeltaX}px)`,\n    );\n    let ratio = currentTransitionPercentage(\n      this.startingX,\n      this.backX,\n      this.startingX + effectiveDeltaX,\n    );\n    styleHeaderElements(\n      ratio,\n      true,\n      this.currentHeaderElement,\n      this.parentHeaderElement,\n    );\n    if (this.currentHeaderElement) {\n      this.currentHeaderElement.style.opacity = ratio;\n    }\n    if (this.parentHeaderElement) {\n      this.parentHeaderElement.style.opacity = 1 - ratio;\n    }\n    if (ev.isFinal) {\n      this._handlePanEnd(ev);\n    }\n  };\n\n  _handlePanEnd(ev) {\n    let effectiveDeltaX = Math.max(0, ev.deltaX);\n    let shouldNavigateBack =\n      this._adjustX(ev.center.x) >= this.thresholdX && this.canNavigateBack;\n    let initialVelocity = ev.velocityX;\n    let fromValue = this.startingX + effectiveDeltaX;\n    let toValue = shouldNavigateBack ? this.backX : this.startingX;\n    this.navStacksService.notifyTransitionStart();\n\n    let finalize = () => {\n      if (shouldNavigateBack) {\n        // The cross-fade ended with parentHeaderElement (target page header)\n        // visible. onBack() will eventually re-render the live header\n        // containers, swapping content: currentHeaderContainer becomes the\n        // target page's header. Snapshot the visible target header into an\n        // overlay clone so it stays on screen across that re-render.\n        // Cleanup is owned by the parent NavStack and runs once the stack\n        // pop actually lands (see PR #79 for the full lifecycle).\n        let overlay = this._cloneTargetHeaderOverlay();\n        if (this.currentHeaderElement) {\n          this.currentHeaderElement.style.opacity = 0;\n          setTransform(\n            this.currentHeaderElement,\n            `translateX(${HEADER_PARALLAX_OFFSET}px)`,\n          );\n        }\n        if (this.parentHeaderElement) {\n          this.parentHeaderElement.style.opacity = 0;\n          setTransform(\n            this.parentHeaderElement,\n            `translateX(${-HEADER_PARALLAX_OFFSET}px)`,\n          );\n        }\n        this.navStacksService.notifyTransitionEnd();\n        this._activeSpring = null;\n        this._unclaimedOverlay = overlay;\n        this.onBackSwipeOverlay?.(overlay);\n        this._unclaimedOverlay = null;\n        run(this.onBack);\n      } else {\n        setTransform(this.containerElement, `translateX(${this.startingX}px)`);\n        if (this.currentHeaderElement) {\n          this.currentHeaderElement.style.opacity = 1;\n          setTransform(this.currentHeaderElement, 'translateX(0px)');\n        }\n        if (this.parentHeaderElement) {\n          this.parentHeaderElement.style.opacity = 0;\n          setTransform(\n            this.parentHeaderElement,\n            `translateX(${-HEADER_PARALLAX_OFFSET}px)`,\n          );\n        }\n        this.navStacksService.notifyTransitionEnd();\n        this._activeSpring = null;\n      }\n    };\n\n    if (fromValue === toValue && initialVelocity === 0) {\n      finalize();\n      return;\n    }\n    let spring = new Spring({\n      initialVelocity,\n      fromValue,\n      toValue,\n      ...SWIPE_SPRING_CONFIG,\n    });\n    this._activeSpring = spring;\n    spring\n      .onUpdate((s) => {\n        setTransform(this.containerElement, `translateX(${s.currentValue}px)`);\n        styleHeaderElements(\n          currentTransitionPercentage(\n            this.startingX,\n            this.backX,\n            s.currentValue,\n          ),\n          false,\n          this.parentHeaderElement,\n          this.currentHeaderElement,\n        );\n        // If the spring's momentum carries it past the back-threshold after\n        // the user released below the threshold, retarget to backX so the\n        // animation completes the back-swipe rather than snapping back.\n        if (\n          !shouldNavigateBack &&\n          s.currentValue >= this.startingX + this.thresholdX\n        ) {\n          shouldNavigateBack = true;\n          spring.updateConfig({ toValue: this.backX });\n        }\n      })\n      .onStop(() => finalize())\n      .start();\n  }\n\n  _cloneTargetHeaderOverlay() {\n    let liveParent = this.element.querySelector(\n      '.NavStack-parentItemHeaderContainer',\n    );\n    if (!liveParent) {\n      return null;\n    }\n    let clone = liveParent.cloneNode(true);\n    clone.classList.remove('NavStack-parentItemHeaderContainer');\n    clone.classList.add('NavStack-gestureBackTargetHeader');\n    clone.style.opacity = '1';\n    setTransform(clone, 'translateX(0px)');\n    // Append last so it paints on top of currentHeaderContainer.\n    this.element.querySelector('.NavStack-header').appendChild(clone);\n    return clone;\n  }\n\n  _getX(element) {\n    return this._adjustX(element.getBoundingClientRect().left);\n  }\n\n  _adjustX(x) {\n    if (macroCondition(isTesting())) {\n      let testingEl = document.querySelector('#ember-testing');\n      if (testingEl) {\n        return x - testingEl.getBoundingClientRect().left;\n      }\n    }\n    return x;\n  }\n}\n"],"names":["SWIPE_SPRING_CONFIG","stiffness","damping","mass","BackSwipeGesture","constructor","element","navStacksService","gestureService","getCanNavigateBack","onBack","onBackSwipeOverlay","hammer","Hammer","Manager","inputClass","TouchMouseInput","recognizers","BackSwipeRecognizer","setupContext","on","_handlePanEvent","register","get","teardown","unregister","off","destroy","_unclaimedOverlay","parentNode","removeChild","disablePan","set","enable","containerElement","querySelector","currentHeaderElement","parentHeaderElement","startingX","_getX","currentStackItemElement","canNavigateBack","itemWidth","getBoundingClientRect","width","backX","thresholdX","threshold","preferRecognizer","recognizer","requireFailure","stopPreferringRecognizer","dropRequireFailure","ev","_activeSpring","effectiveDeltaX","Math","max","deltaX","setTransform","ratio","currentTransitionPercentage","styleHeaderElements","style","opacity","isFinal","_handlePanEnd","shouldNavigateBack","_adjustX","center","x","initialVelocity","velocityX","fromValue","toValue","notifyTransitionStart","finalize","overlay","_cloneTargetHeaderOverlay","HEADER_PARALLAX_OFFSET","notifyTransitionEnd","run","spring","Spring","onUpdate","s","currentValue","updateConfig","onStop","start","liveParent","clone","cloneNode","classList","remove","add","appendChild","left","macroCondition","isTesting","testingEl","document"],"mappings":"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"}

package/dist/components/nav-stack-inner-wrapper.js

@@ -0,0 +1,10 @@
+import templateOnly from '@ember/component/template-only';
+import { precompileTemplate } from '@ember/template-compilation';
+import { setComponentTemplate } from '@ember/component';
+
+var TEMPLATE = precompileTemplate("{{#if @class}}\n  <div class={{concat \"NavStack-innerWrapper \" @class}}>\n    {{yield}}\n  </div>\n{{else}}\n  {{yield}}\n{{/if}}");
+
+var navStackInnerWrapper = setComponentTemplate(TEMPLATE, templateOnly());
+
+export { navStackInnerWrapper as default };
+//# sourceMappingURL=nav-stack-inner-wrapper.js.map

package/dist/components/nav-stack-inner-wrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nav-stack-inner-wrapper.js","sources":["../../src/components/nav-stack-inner-wrapper.js"],"sourcesContent":["import templateOnly from '@ember/component/template-only';\n\n// Private template-only helper. Wraps its block in a\n// `<div class=\"NavStack-innerWrapper [class]\">` when `@class` is truthy, or\n// passes the block through unwrapped when it's falsy. This is the structural\n// mechanism behind `<NavStack @innerWrapperClass>`: omitting the arg leaves\n// the addon's DOM identical to pre-v7.1 (so consumer CSS using direct-child\n// selectors on `.NavStack` continues to match), while providing it inserts\n// the extra wrapper element on demand.\n//\n// Not part of the addon's public API — invoked only from `<NavStack>`'s\n// own template. Subject to change without notice.\nexport default templateOnly();\n"],"names":["setComponentTemplate","TEMPLATE","templateOnly"],"mappings":";;;;;;AAYA,2BAAAA,oBAAA,CAAAC,QAAA,EAAeC,YAAY,EAAE,CAAA;;;;"}