ember-nav-stack 6.1.2 → 7.1.0

package/dist/utils/back-swipe-recognizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"back-swipe-recognizer.js","sources":["../../src/utils/back-swipe-recognizer.js"],"sourcesContent":["import Hammer from 'hammerjs';\nimport { macroCondition, isTesting } from '@embroider/macros';\nconst { DIRECTION_RIGHT } = Hammer;\nconst FIELD_REGEXP = /input|textarea|select/i;\n\n/* This recognizer subclasses the Pan recognizer and adds the constraint that the initial touch\n * must be in the validLeftAreaPercent portion of the screen.\n */\nexport default class BackSwipeRecognizer extends Hammer.Pan {\n  constructor(options) {\n    super(options);\n    this.options = Object.assign({}, this.defaults, options || {});\n    this.captureClick = (ev) => {\n      ev.stopPropagation(); // Stop the click from being propagated.\n      this.manager.element.removeEventListener(\n        'click',\n        this.captureClick,\n        true,\n      );\n    };\n  }\n\n  defaults = {\n    enable: true,\n    event: 'pan',\n    threshold: 10,\n    pointers: 1,\n    direction: DIRECTION_RIGHT,\n    validLeftAreaPercent: 33,\n  };\n\n  recognize(inputData) {\n    if (inputData.isFirst) {\n      this.isInitialTouchInValidArea =\n        this.checkInitialTouchInValidArea(inputData);\n    }\n    let isOverElementThatPreventsScrollingInteraction =\n      this.shouldPreventScrollingInteraction(inputData);\n    if (isOverElementThatPreventsScrollingInteraction) {\n      this.manager.stop();\n      return;\n    }\n    this.captureGhostClickIfNeeded(inputData);\n    super.recognize(inputData);\n    if (inputData.isFinal) {\n      setTimeout(() => {\n        this.state = Hammer.STATE_POSSIBLE;\n      }, 0);\n    }\n  }\n\n  shouldPreventScrollingInteraction(inputData) {\n    let { target } = inputData;\n    return (\n      inputData.isFirst &&\n      ((target && target.tagName.match(FIELD_REGEXP)) ||\n        (target && target.hasAttribute('data-prevent-scrolling')))\n    );\n  }\n\n  captureGhostClickIfNeeded(inputData) {\n    if (\n      inputData.srcEvent.type === 'mouseup' &&\n      this.state & Hammer.STATE_BEGAN\n    ) {\n      this.manager.element.addEventListener('click', this.captureClick, true);\n      setTimeout(() => {\n        this.manager.element.removeEventListener(\n          'click',\n          this.captureClick,\n          true,\n        );\n      }, 0);\n    }\n  }\n\n  reset() {\n    this.isInitialTouchInValidArea = undefined;\n  }\n\n  checkInitialTouchInValidArea(inputData) {\n    if (macroCondition(isTesting())) {\n      let testingEl = document.querySelector('#ember-testing');\n      if (testingEl) {\n        let testingRect = testingEl.getBoundingClientRect();\n        let minValidX = testingRect.left;\n        let maxValidX =\n          minValidX +\n          testingEl.clientWidth * (this.options.validLeftAreaPercent / 100);\n        return (\n          inputData.center.x >= minValidX && inputData.center.x <= maxValidX\n        );\n      }\n    }\n    let maxValidX =\n      window.innerWidth * (this.options.validLeftAreaPercent / 100);\n    return inputData.center.x <= maxValidX;\n  }\n\n  attrTest(input) {\n    return this.isInitialTouchInValidArea && super.attrTest(input);\n  }\n}\n"],"names":["DIRECTION_RIGHT","Hammer","FIELD_REGEXP","BackSwipeRecognizer","Pan","constructor","options","Object","assign","defaults","captureClick","ev","stopPropagation","manager","element","removeEventListener","enable","event","threshold","pointers","direction","validLeftAreaPercent","recognize","inputData","isFirst","isInitialTouchInValidArea","checkInitialTouchInValidArea","isOverElementThatPreventsScrollingInteraction","shouldPreventScrollingInteraction","stop","captureGhostClickIfNeeded","isFinal","setTimeout","state","STATE_POSSIBLE","target","tagName","match","hasAttribute","srcEvent","type","STATE_BEGAN","addEventListener","reset","undefined","macroCondition","isTesting","testingEl","document","querySelector","testingRect","getBoundingClientRect","minValidX","left","maxValidX","clientWidth","center","x","window","innerWidth","attrTest","input"],"mappings":"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"}

package/dist/utils/clone-store.js

@@ -0,0 +1,88 @@
+// Tracks groups of cloned DOM nodes so they can be removed from the document
+// as a unit. NavStack creates four groups during its animations:
+//
+//   - 'stackItems'           — the last item cloned for a slideBack
+//   - 'headers'              — the leaving header cloned for slide animations
+//   - 'elements'             — the whole NavStack cloned for slideDown
+//   - 'gestureBackOverlays'  — target-header snapshot during a back-swipe
+//                              (lifecycle described in PR #79's commit body)
+//
+// The store doesn't know how to CREATE the clones — callers do the
+// `.cloneNode(true)` + attach themselves and pass the result to `track()`.
+// What the store provides is uniform cleanup (`remove()`, `clear()`,
+// `clearAll()`) with a `parentNode?.removeChild` guard so a clone whose
+// parent has already been removed from the DOM is dropped silently rather
+// than throwing.
+class CloneStore {
+  #groups = new Map();
+
+  // Records `clone` under `groupName`. Tracking the same clone twice in the
+  // same group is a no-op. (Tracking the same clone in MULTIPLE groups is
+  // not prevented — but no caller does that today; each clone has one
+  // logical owner group based on which slide animation created it.)
+  track(groupName, clone) {
+    if (!clone) {
+      return;
+    }
+    let group = this.#groups.get(groupName);
+    if (!group) {
+      group = [];
+      this.#groups.set(groupName, group);
+    }
+    if (group.indexOf(clone) === -1) {
+      group.push(clone);
+    }
+  }
+
+  // Removes a specific clone from a group AND from the DOM. Safe to call
+  // when the clone has already been detached.
+  remove(groupName, clone) {
+    if (!clone) {
+      return;
+    }
+    let group = this.#groups.get(groupName);
+    if (group) {
+      let idx = group.indexOf(clone);
+      if (idx !== -1) {
+        group.splice(idx, 1);
+      }
+    }
+    if (clone.parentNode) {
+      clone.parentNode.removeChild(clone);
+    }
+  }
+
+  // Removes every clone in a group from the DOM and empties the group.
+  // Safe to call when the group doesn't exist yet.
+  clear(groupName) {
+    let group = this.#groups.get(groupName);
+    if (!group) {
+      return;
+    }
+    let clone;
+    while (clone = group.pop()) {
+      if (clone.parentNode) {
+        clone.parentNode.removeChild(clone);
+      }
+    }
+  }
+
+  // Clears every group. Used in NavStack's willDestroy to sweep anything
+  // left over from abandoned transitions.
+  clearAll() {
+    for (let groupName of this.#groups.keys()) {
+      this.clear(groupName);
+    }
+  }
+
+  // Convenience for reading "the most recently tracked clone in this group"
+  // — used by NavStack's slideDown which needs the cloned-NavStack element
+  // it just produced. Returns undefined for empty/missing groups.
+  last(groupName) {
+    let group = this.#groups.get(groupName);
+    return group?.[group.length - 1];
+  }
+}
+
+export { CloneStore as default };
+//# sourceMappingURL=clone-store.js.map

package/dist/utils/clone-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-store.js","sources":["../../src/utils/clone-store.js"],"sourcesContent":["// Tracks groups of cloned DOM nodes so they can be removed from the document\n// as a unit. NavStack creates four groups during its animations:\n//\n//   - 'stackItems'           — the last item cloned for a slideBack\n//   - 'headers'              — the leaving header cloned for slide animations\n//   - 'elements'             — the whole NavStack cloned for slideDown\n//   - 'gestureBackOverlays'  — target-header snapshot during a back-swipe\n//                              (lifecycle described in PR #79's commit body)\n//\n// The store doesn't know how to CREATE the clones — callers do the\n// `.cloneNode(true)` + attach themselves and pass the result to `track()`.\n// What the store provides is uniform cleanup (`remove()`, `clear()`,\n// `clearAll()`) with a `parentNode?.removeChild` guard so a clone whose\n// parent has already been removed from the DOM is dropped silently rather\n// than throwing.\nexport default class CloneStore {\n  #groups = new Map();\n\n  // Records `clone` under `groupName`. Tracking the same clone twice in the\n  // same group is a no-op. (Tracking the same clone in MULTIPLE groups is\n  // not prevented — but no caller does that today; each clone has one\n  // logical owner group based on which slide animation created it.)\n  track(groupName, clone) {\n    if (!clone) {\n      return;\n    }\n    let group = this.#groups.get(groupName);\n    if (!group) {\n      group = [];\n      this.#groups.set(groupName, group);\n    }\n    if (group.indexOf(clone) === -1) {\n      group.push(clone);\n    }\n  }\n\n  // Removes a specific clone from a group AND from the DOM. Safe to call\n  // when the clone has already been detached.\n  remove(groupName, clone) {\n    if (!clone) {\n      return;\n    }\n    let group = this.#groups.get(groupName);\n    if (group) {\n      let idx = group.indexOf(clone);\n      if (idx !== -1) {\n        group.splice(idx, 1);\n      }\n    }\n    if (clone.parentNode) {\n      clone.parentNode.removeChild(clone);\n    }\n  }\n\n  // Removes every clone in a group from the DOM and empties the group.\n  // Safe to call when the group doesn't exist yet.\n  clear(groupName) {\n    let group = this.#groups.get(groupName);\n    if (!group) {\n      return;\n    }\n    let clone;\n    while ((clone = group.pop())) {\n      if (clone.parentNode) {\n        clone.parentNode.removeChild(clone);\n      }\n    }\n  }\n\n  // Clears every group. Used in NavStack's willDestroy to sweep anything\n  // left over from abandoned transitions.\n  clearAll() {\n    for (let groupName of this.#groups.keys()) {\n      this.clear(groupName);\n    }\n  }\n\n  // Convenience for reading \"the most recently tracked clone in this group\"\n  // — used by NavStack's slideDown which needs the cloned-NavStack element\n  // it just produced. Returns undefined for empty/missing groups.\n  last(groupName) {\n    let group = this.#groups.get(groupName);\n    return group?.[group.length - 1];\n  }\n}\n"],"names":["CloneStore","Map","track","groupName","clone","group","get","set","indexOf","push","remove","idx","splice","parentNode","removeChild","clear","pop","clearAll","keys","last","length"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,MAAMA,UAAU,CAAC;AAC9B,EAAA,OAAO,GAAG,IAAIC,GAAG,EAAE;;AAEnB;AACA;AACA;AACA;AACAC,EAAAA,KAAKA,CAACC,SAAS,EAAEC,KAAK,EAAE;IACtB,IAAI,CAACA,KAAK,EAAE;AACV,MAAA;AACF,IAAA;IACA,IAAIC,KAAK,GAAG,IAAI,CAAC,OAAO,CAACC,GAAG,CAACH,SAAS,CAAC;IACvC,IAAI,CAACE,KAAK,EAAE;AACVA,MAAAA,KAAK,GAAG,EAAE;MACV,IAAI,CAAC,OAAO,CAACE,GAAG,CAACJ,SAAS,EAAEE,KAAK,CAAC;AACpC,IAAA;IACA,IAAIA,KAAK,CAACG,OAAO,CAACJ,KAAK,CAAC,KAAK,EAAE,EAAE;AAC/BC,MAAAA,KAAK,CAACI,IAAI,CAACL,KAAK,CAAC;AACnB,IAAA;AACF,EAAA;;AAEA;AACA;AACAM,EAAAA,MAAMA,CAACP,SAAS,EAAEC,KAAK,EAAE;IACvB,IAAI,CAACA,KAAK,EAAE;AACV,MAAA;AACF,IAAA;IACA,IAAIC,KAAK,GAAG,IAAI,CAAC,OAAO,CAACC,GAAG,CAACH,SAAS,CAAC;AACvC,IAAA,IAAIE,KAAK,EAAE;AACT,MAAA,IAAIM,GAAG,GAAGN,KAAK,CAACG,OAAO,CAACJ,KAAK,CAAC;AAC9B,MAAA,IAAIO,GAAG,KAAK,EAAE,EAAE;AACdN,QAAAA,KAAK,CAACO,MAAM,CAACD,GAAG,EAAE,CAAC,CAAC;AACtB,MAAA;AACF,IAAA;IACA,IAAIP,KAAK,CAACS,UAAU,EAAE;AACpBT,MAAAA,KAAK,CAACS,UAAU,CAACC,WAAW,CAACV,KAAK,CAAC;AACrC,IAAA;AACF,EAAA;;AAEA;AACA;EACAW,KAAKA,CAACZ,SAAS,EAAE;IACf,IAAIE,KAAK,GAAG,IAAI,CAAC,OAAO,CAACC,GAAG,CAACH,SAAS,CAAC;IACvC,IAAI,CAACE,KAAK,EAAE;AACV,MAAA;AACF,IAAA;AACA,IAAA,IAAID,KAAK;AACT,IAAA,OAAQA,KAAK,GAAGC,KAAK,CAACW,GAAG,EAAE,EAAG;MAC5B,IAAIZ,KAAK,CAACS,UAAU,EAAE;AACpBT,QAAAA,KAAK,CAACS,UAAU,CAACC,WAAW,CAACV,KAAK,CAAC;AACrC,MAAA;AACF,IAAA;AACF,EAAA;;AAEA;AACA;AACAa,EAAAA,QAAQA,GAAG;IACT,KAAK,IAAId,SAAS,IAAI,IAAI,CAAC,OAAO,CAACe,IAAI,EAAE,EAAE;AACzC,MAAA,IAAI,CAACH,KAAK,CAACZ,SAAS,CAAC;AACvB,IAAA;AACF,EAAA;;AAEA;AACA;AACA;EACAgB,IAAIA,CAAChB,SAAS,EAAE;IACd,IAAIE,KAAK,GAAG,IAAI,CAAC,OAAO,CAACC,GAAG,CAACH,SAAS,CAAC;AACvC,IAAA,OAAOE,KAAK,GAAGA,KAAK,CAACe,MAAM,GAAG,CAAC,CAAC;AAClC,EAAA;AACF;;;;"}

package/dist/utils/component.js

@@ -0,0 +1,121 @@
+import { macroCondition, isDevelopingApp } from '@embroider/macros';
+
+function extractComponentKey(componentRef) {
+  if (!componentRef) {
+    return 'none';
+  }
+  let result = getComponentRefName(componentRef);
+  // Dev-only safeguard: if every access path failed to produce a name, the
+  // Glimmer reference's shape has likely changed (it has before — see the
+  // INNER-slot-as-string vs. -as-object update further down) and we'd
+  // otherwise return `undefined` silently. That makes
+  // `rootComponentKey !== this._rootComponentKey` always compare
+  // `'undefined' === 'undefined'`, so root-change cuts (e.g. tab switches)
+  // would never fire and the addon would silently fall through to a slide
+  // animation. Failing loud here surfaces the breakage at the source.
+  //
+  // Gated on `@embroider/macros`'s `isDevelopingApp()` so the entire check
+  // (including the message string) is stripped from production builds by
+  // the consumer's babel pipeline — both Embroider and classic ember-cli
+  // run the macros transform on v2 addon code, unlike
+  // `babel-plugin-debug-macros` (which only applies to app + v1 addon
+  // code in classic builds and would leave the string in the bundle).
+  if (macroCondition(isDevelopingApp())) {
+    if (result === undefined) {
+      throw new Error('[ember-nav-stack] extractComponentKey could not derive a name from the component reference. The Glimmer reference shape has likely changed; see src/utils/component.js.');
+    }
+  }
+  let modelId = getComponentRefModelId(componentRef);
+  if (modelId) {
+    result += `:${modelId}`;
+  }
+  return result;
+}
+
+// Component-name-only key for a curried component reference. Skips the
+// `model.id` appendage that `extractComponentKey` adds because, unlike the
+// component name (which is set at curry time), the model ref's `lastValue`
+// resolves lazily — the active-item-change path needs a key that's stable
+// the moment the curry exists, otherwise a single push fires twice as the
+// model id transitions from undefined to its concrete value across two
+// render ticks.
+function extractComponentName(componentRef) {
+  if (!componentRef) {
+    return 'none';
+  }
+  return getComponentRefName(componentRef);
+}
+function getComponentRefName(componentRef) {
+  if (componentRef.name) {
+    return componentRef.name;
+  }
+  let innerSym = Object.getOwnPropertySymbols(componentRef).find(s => s.description === 'INNER');
+  let inner = componentRef.inner || innerSym && componentRef[innerSym];
+  // In modern Glimmer, a curried component's INNER slot holds the resolved
+  // component name as a string. Older builds wrapped it in an object with
+  // a `.name` property.
+  if (typeof inner === 'string') {
+    return inner;
+  }
+  return inner?.name;
+}
+
+// Resolve a Glimmer reference to its current value without importing from
+// `@glimmer/reference` (which would couple this addon to a specific
+// Glimmer release line and cause dedupe headaches under strict resolvers).
+// Three paths:
+//   1. `ref.value()` — classic Glimmer (pre-2020-ish).
+//   2. `ref.compute()` — modern Glimmer. Calls the underlying compute
+//      function, which both recomputes the live value AND consumes the
+//      ref's tag so we participate in autotracking. This is critical for
+//      the `stackItemsFingerprint` getter: without it, we'd be reading
+//      `lastValue` (a snapshot from the last render that consumed this
+//      ref) and miss in-place arg changes — e.g. a parent route swapping
+//      its `model` while keeping the same curried component instance
+//      alive. The fingerprint would then stay stale and the NavStack
+//      would miss the root-key change entirely (next stack mutation
+//      would lump the root change with the depth change and degenerate
+//      to a cut, suppressing the expected slide).
+//   3. `ref.lastValue` — last-resort fallback.
+// `extractComponentKey` is
+// invoked from `<NavStack>`'s reactive `stackItemsFingerprint` getter
+// whose own re-evaluation is what propagated the change in the first place.
+function valueForRef(ref) {
+  if (!ref) {
+    return ref;
+  }
+  if (typeof ref.value === 'function') {
+    return ref.value();
+  }
+  if (typeof ref.compute === 'function') {
+    return ref.compute();
+  }
+  return ref.lastValue;
+}
+function getComponentRefModelId(componentRef) {
+  let argsSym = Object.getOwnPropertySymbols(componentRef).find(s => s.description === 'ARGS');
+  let args = componentRef.args || argsSym && componentRef[argsSym];
+  if (!args || !args.named) {
+    return;
+  }
+  let named = args.named;
+  let modelRef;
+  if (typeof named.has === 'function' && named.has('model')) {
+    // Older Glimmer exposed named args as a Map-like with has/get.
+    modelRef = named.get('model');
+  } else if (named.model) {
+    // Modern Glimmer: args.named is a POJO of references keyed by arg name.
+    modelRef = named.model;
+  }
+  if (!modelRef) {
+    return;
+  }
+  let model = valueForRef(modelRef);
+  if (model) {
+    return model.id;
+  }
+  return;
+}
+
+export { extractComponentKey, extractComponentName };
+//# sourceMappingURL=component.js.map

package/dist/utils/component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.js","sources":["../../src/utils/component.js"],"sourcesContent":["import { macroCondition, isDevelopingApp } from '@embroider/macros';\n\nexport function extractComponentKey(componentRef) {\n  if (!componentRef) {\n    return 'none';\n  }\n  let result = getComponentRefName(componentRef);\n  // Dev-only safeguard: if every access path failed to produce a name, the\n  // Glimmer reference's shape has likely changed (it has before — see the\n  // INNER-slot-as-string vs. -as-object update further down) and we'd\n  // otherwise return `undefined` silently. That makes\n  // `rootComponentKey !== this._rootComponentKey` always compare\n  // `'undefined' === 'undefined'`, so root-change cuts (e.g. tab switches)\n  // would never fire and the addon would silently fall through to a slide\n  // animation. Failing loud here surfaces the breakage at the source.\n  //\n  // Gated on `@embroider/macros`'s `isDevelopingApp()` so the entire check\n  // (including the message string) is stripped from production builds by\n  // the consumer's babel pipeline — both Embroider and classic ember-cli\n  // run the macros transform on v2 addon code, unlike\n  // `babel-plugin-debug-macros` (which only applies to app + v1 addon\n  // code in classic builds and would leave the string in the bundle).\n  if (macroCondition(isDevelopingApp())) {\n    if (result === undefined) {\n      throw new Error(\n        '[ember-nav-stack] extractComponentKey could not derive a name from the component reference. The Glimmer reference shape has likely changed; see src/utils/component.js.',\n      );\n    }\n  }\n  let modelId = getComponentRefModelId(componentRef);\n  if (modelId) {\n    result += `:${modelId}`;\n  }\n  return result;\n}\n\n// Component-name-only key for a curried component reference. Skips the\n// `model.id` appendage that `extractComponentKey` adds because, unlike the\n// component name (which is set at curry time), the model ref's `lastValue`\n// resolves lazily — the active-item-change path needs a key that's stable\n// the moment the curry exists, otherwise a single push fires twice as the\n// model id transitions from undefined to its concrete value across two\n// render ticks.\nexport function extractComponentName(componentRef) {\n  if (!componentRef) {\n    return 'none';\n  }\n  return getComponentRefName(componentRef);\n}\n\nfunction getComponentRefName(componentRef) {\n  if (componentRef.name) {\n    return componentRef.name;\n  }\n  let innerSym = Object.getOwnPropertySymbols(componentRef).find(\n    (s) => s.description === 'INNER',\n  );\n  let inner = componentRef.inner || (innerSym && componentRef[innerSym]);\n  // In modern Glimmer, a curried component's INNER slot holds the resolved\n  // component name as a string. Older builds wrapped it in an object with\n  // a `.name` property.\n  if (typeof inner === 'string') {\n    return inner;\n  }\n  return inner?.name;\n}\n\n// Resolve a Glimmer reference to its current value without importing from\n// `@glimmer/reference` (which would couple this addon to a specific\n// Glimmer release line and cause dedupe headaches under strict resolvers).\n// Three paths:\n//   1. `ref.value()` — classic Glimmer (pre-2020-ish).\n//   2. `ref.compute()` — modern Glimmer. Calls the underlying compute\n//      function, which both recomputes the live value AND consumes the\n//      ref's tag so we participate in autotracking. This is critical for\n//      the `stackItemsFingerprint` getter: without it, we'd be reading\n//      `lastValue` (a snapshot from the last render that consumed this\n//      ref) and miss in-place arg changes — e.g. a parent route swapping\n//      its `model` while keeping the same curried component instance\n//      alive. The fingerprint would then stay stale and the NavStack\n//      would miss the root-key change entirely (next stack mutation\n//      would lump the root change with the depth change and degenerate\n//      to a cut, suppressing the expected slide).\n//   3. `ref.lastValue` — last-resort fallback.\n// `extractComponentKey` is\n// invoked from `<NavStack>`'s reactive `stackItemsFingerprint` getter\n// whose own re-evaluation is what propagated the change in the first place.\nfunction valueForRef(ref) {\n  if (!ref) {\n    return ref;\n  }\n  if (typeof ref.value === 'function') {\n    return ref.value();\n  }\n  if (typeof ref.compute === 'function') {\n    return ref.compute();\n  }\n  return ref.lastValue;\n}\n\nfunction getComponentRefModelId(componentRef) {\n  let argsSym = Object.getOwnPropertySymbols(componentRef).find(\n    (s) => s.description === 'ARGS',\n  );\n  let args = componentRef.args || (argsSym && componentRef[argsSym]);\n  if (!args || !args.named) {\n    return;\n  }\n  let named = args.named;\n  let modelRef;\n  if (typeof named.has === 'function' && named.has('model')) {\n    // Older Glimmer exposed named args as a Map-like with has/get.\n    modelRef = named.get('model');\n  } else if (named.model) {\n    // Modern Glimmer: args.named is a POJO of references keyed by arg name.\n    modelRef = named.model;\n  }\n  if (!modelRef) {\n    return;\n  }\n  let model = valueForRef(modelRef);\n  if (model) {\n    return model.id;\n  }\n  return;\n}\n"],"names":["extractComponentKey","componentRef","result","getComponentRefName","macroCondition","isDevelopingApp","undefined","Error","modelId","getComponentRefModelId","extractComponentName","name","innerSym","Object","getOwnPropertySymbols","find","s","description","inner","valueForRef","ref","value","compute","lastValue","argsSym","args","named","modelRef","has","get","model","id"],"mappings":"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"}

package/dist/utils/header-style.js

@@ -0,0 +1,46 @@
+import { setTransform } from './animation.js';
+
+// Pixels of parallax applied to the header elements during a horizontal
+// transition. The currentHeaderContainer slides this far while the parent
+// (target page) header slides in from the opposite direction.
+const HEADER_PARALLAX_OFFSET = 60;
+
+// Maps an animation's current value (e.g. translateX in CSS px) to a 0..1
+// ratio representing how far the transition has progressed from fromValue
+// to toValue. Returns 1 when fromValue is unset or equal to toValue (used by
+// the no-op case in horizontalTransition).
+function currentTransitionPercentage(fromValue, toValue, currentValue) {
+  if (fromValue === undefined || fromValue === toValue) {
+    return 1;
+  }
+  let percentage = Math.abs((currentValue - fromValue) / (toValue - fromValue));
+  if (toValue > fromValue) {
+    return 1 - percentage;
+  }
+  return percentage;
+}
+
+// Cross-fades and translates two header elements as a horizontal transition
+// progresses. `isForward` controls which direction the offset goes (forward
+// transitions push the leaving header rightward; back transitions leftward).
+// Either element argument may be null — both are conditionally available
+// during slideBack/slideForward and the swipe-driven path.
+function styleHeaderElements(transitionRatio, isForward, currentHeaderElement, otherHeaderElement) {
+  let startingOffset = HEADER_PARALLAX_OFFSET;
+  if (!isForward) {
+    transitionRatio = 1 - transitionRatio;
+    startingOffset = -1 * startingOffset;
+  }
+  let xOffset = transitionRatio * -1 * startingOffset;
+  if (currentHeaderElement) {
+    currentHeaderElement.style.opacity = transitionRatio;
+    setTransform(currentHeaderElement, `translateX(${startingOffset + xOffset}px)`);
+  }
+  if (otherHeaderElement) {
+    otherHeaderElement.style.opacity = 1 - transitionRatio;
+    setTransform(otherHeaderElement, `translateX(${xOffset}px)`);
+  }
+}
+
+export { HEADER_PARALLAX_OFFSET, currentTransitionPercentage, styleHeaderElements };
+//# sourceMappingURL=header-style.js.map

package/dist/utils/header-style.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-style.js","sources":["../../src/utils/header-style.js"],"sourcesContent":["import { setTransform } from './animation.js';\n\n// Pixels of parallax applied to the header elements during a horizontal\n// transition. The currentHeaderContainer slides this far while the parent\n// (target page) header slides in from the opposite direction.\nexport const HEADER_PARALLAX_OFFSET = 60;\n\n// Maps an animation's current value (e.g. translateX in CSS px) to a 0..1\n// ratio representing how far the transition has progressed from fromValue\n// to toValue. Returns 1 when fromValue is unset or equal to toValue (used by\n// the no-op case in horizontalTransition).\nexport function currentTransitionPercentage(fromValue, toValue, currentValue) {\n  if (fromValue === undefined || fromValue === toValue) {\n    return 1;\n  }\n  let percentage = Math.abs((currentValue - fromValue) / (toValue - fromValue));\n  if (toValue > fromValue) {\n    return 1 - percentage;\n  }\n  return percentage;\n}\n\n// Cross-fades and translates two header elements as a horizontal transition\n// progresses. `isForward` controls which direction the offset goes (forward\n// transitions push the leaving header rightward; back transitions leftward).\n// Either element argument may be null — both are conditionally available\n// during slideBack/slideForward and the swipe-driven path.\nexport function styleHeaderElements(\n  transitionRatio,\n  isForward,\n  currentHeaderElement,\n  otherHeaderElement,\n) {\n  let startingOffset = HEADER_PARALLAX_OFFSET;\n  if (!isForward) {\n    transitionRatio = 1 - transitionRatio;\n    startingOffset = -1 * startingOffset;\n  }\n  let xOffset = transitionRatio * -1 * startingOffset;\n  if (currentHeaderElement) {\n    currentHeaderElement.style.opacity = transitionRatio;\n    setTransform(\n      currentHeaderElement,\n      `translateX(${startingOffset + xOffset}px)`,\n    );\n  }\n  if (otherHeaderElement) {\n    otherHeaderElement.style.opacity = 1 - transitionRatio;\n    setTransform(otherHeaderElement, `translateX(${xOffset}px)`);\n  }\n}\n"],"names":["HEADER_PARALLAX_OFFSET","currentTransitionPercentage","fromValue","toValue","currentValue","undefined","percentage","Math","abs","styleHeaderElements","transitionRatio","isForward","currentHeaderElement","otherHeaderElement","startingOffset","xOffset","style","opacity","setTransform"],"mappings":";;AAEA;AACA;AACA;AACO,MAAMA,sBAAsB,GAAG;;AAEtC;AACA;AACA;AACA;AACO,SAASC,2BAA2BA,CAACC,SAAS,EAAEC,OAAO,EAAEC,YAAY,EAAE;AAC5E,EAAA,IAAIF,SAAS,KAAKG,SAAS,IAAIH,SAAS,KAAKC,OAAO,EAAE;AACpD,IAAA,OAAO,CAAC;AACV,EAAA;AACA,EAAA,IAAIG,UAAU,GAAGC,IAAI,CAACC,GAAG,CAAC,CAACJ,YAAY,GAAGF,SAAS,KAAKC,OAAO,GAAGD,SAAS,CAAC,CAAC;EAC7E,IAAIC,OAAO,GAAGD,SAAS,EAAE;IACvB,OAAO,CAAC,GAAGI,UAAU;AACvB,EAAA;AACA,EAAA,OAAOA,UAAU;AACnB;;AAEA;AACA;AACA;AACA;AACA;AACO,SAASG,mBAAmBA,CACjCC,eAAe,EACfC,SAAS,EACTC,oBAAoB,EACpBC,kBAAkB,EAClB;EACA,IAAIC,cAAc,GAAGd,sBAAsB;EAC3C,IAAI,CAACW,SAAS,EAAE;IACdD,eAAe,GAAG,CAAC,GAAGA,eAAe;AACrCI,IAAAA,cAAc,GAAG,EAAE,GAAGA,cAAc;AACtC,EAAA;AACA,EAAA,IAAIC,OAAO,GAAGL,eAAe,GAAG,EAAE,GAAGI,cAAc;AACnD,EAAA,IAAIF,oBAAoB,EAAE;AACxBA,IAAAA,oBAAoB,CAACI,KAAK,CAACC,OAAO,GAAGP,eAAe;IACpDQ,YAAY,CACVN,oBAAoB,EACpB,CAAA,WAAA,EAAcE,cAAc,GAAGC,OAAO,KACxC,CAAC;AACH,EAAA;AACA,EAAA,IAAIF,kBAAkB,EAAE;AACtBA,IAAAA,kBAAkB,CAACG,KAAK,CAACC,OAAO,GAAG,CAAC,GAAGP,eAAe;AACtDQ,IAAAA,YAAY,CAACL,kBAAkB,EAAE,CAAA,WAAA,EAAcE,OAAO,KAAK,CAAC;AAC9D,EAAA;AACF;;;;"}

package/dist/utils/transition-decision.js

@@ -0,0 +1,71 @@
+// Pure function mapping an observed stack-state change to a transition intent.
+//
+// The full truth table is exercised by
+// test-app/tests/unit/utils/transition-decision-test.js. Summary:
+//
+//   isInitialRender                  → cut
+//   layer>0, prev=0, next>0          → slideUp                     (underlay appears)
+//   prev=undefined (first observation) → slideUp
+//   layer>0, prev>0, next=0          → slideDown                   (underlay disappears)
+//   newRootKey ≠ previousRootKey     → cut, startsRootChange=true
+//   next<prev, !rootJustChanged      → slideBack
+//   next<prev, rootJustChanged       → cut    (depth change rides on root change)
+//   next>prev, !rootJustChanged      → slideForward
+//   next>prev, rootJustChanged       → cut
+//   next===prev, same root, !initial → none
+//
+// `rootJustChanged` is set by the caller when a previous call in the same
+// runloop tick produced a root-change intent. It exists because multiple
+// service flushes can land in the same tick (e.g. parent-route swap +
+// drilled-child exit during a tab switch); without coalescing, the second
+// flush would animate over the cut from the first.
+
+function decideTransition({
+  isInitialRender,
+  previousDepth,
+  newDepth,
+  previousRootKey,
+  newRootKey,
+  layer,
+  rootJustChanged
+}) {
+  if (isInitialRender) {
+    return {
+      kind: 'cut'
+    };
+  }
+  let appearsAsUnderlay = layer > 0 && newDepth > 0 && previousDepth === 0;
+  if (appearsAsUnderlay || previousDepth === undefined) {
+    return {
+      kind: 'slideUp'
+    };
+  }
+  let disappearsAsUnderlay = layer > 0 && newDepth === 0 && previousDepth > 0;
+  if (disappearsAsUnderlay) {
+    return {
+      kind: 'slideDown'
+    };
+  }
+  if (newRootKey !== previousRootKey) {
+    return {
+      kind: 'cut',
+      startsRootChange: true
+    };
+  }
+  if (newDepth < previousDepth) {
+    return {
+      kind: rootJustChanged ? 'cut' : 'slideBack'
+    };
+  }
+  if (newDepth > previousDepth) {
+    return {
+      kind: rootJustChanged ? 'cut' : 'slideForward'
+    };
+  }
+  return {
+    kind: 'none'
+  };
+}
+
+export { decideTransition };
+//# sourceMappingURL=transition-decision.js.map

package/dist/utils/transition-decision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transition-decision.js","sources":["../../src/utils/transition-decision.js"],"sourcesContent":["// Pure function mapping an observed stack-state change to a transition intent.\n//\n// The full truth table is exercised by\n// test-app/tests/unit/utils/transition-decision-test.js. Summary:\n//\n//   isInitialRender                  → cut\n//   layer>0, prev=0, next>0          → slideUp                     (underlay appears)\n//   prev=undefined (first observation) → slideUp\n//   layer>0, prev>0, next=0          → slideDown                   (underlay disappears)\n//   newRootKey ≠ previousRootKey     → cut, startsRootChange=true\n//   next<prev, !rootJustChanged      → slideBack\n//   next<prev, rootJustChanged       → cut    (depth change rides on root change)\n//   next>prev, !rootJustChanged      → slideForward\n//   next>prev, rootJustChanged       → cut\n//   next===prev, same root, !initial → none\n//\n// `rootJustChanged` is set by the caller when a previous call in the same\n// runloop tick produced a root-change intent. It exists because multiple\n// service flushes can land in the same tick (e.g. parent-route swap +\n// drilled-child exit during a tab switch); without coalescing, the second\n// flush would animate over the cut from the first.\n\nexport function decideTransition({\n  isInitialRender,\n  previousDepth,\n  newDepth,\n  previousRootKey,\n  newRootKey,\n  layer,\n  rootJustChanged,\n}) {\n  if (isInitialRender) {\n    return { kind: 'cut' };\n  }\n\n  let appearsAsUnderlay = layer > 0 && newDepth > 0 && previousDepth === 0;\n  if (appearsAsUnderlay || previousDepth === undefined) {\n    return { kind: 'slideUp' };\n  }\n\n  let disappearsAsUnderlay = layer > 0 && newDepth === 0 && previousDepth > 0;\n  if (disappearsAsUnderlay) {\n    return { kind: 'slideDown' };\n  }\n\n  if (newRootKey !== previousRootKey) {\n    return { kind: 'cut', startsRootChange: true };\n  }\n\n  if (newDepth < previousDepth) {\n    return { kind: rootJustChanged ? 'cut' : 'slideBack' };\n  }\n  if (newDepth > previousDepth) {\n    return { kind: rootJustChanged ? 'cut' : 'slideForward' };\n  }\n\n  return { kind: 'none' };\n}\n"],"names":["decideTransition","isInitialRender","previousDepth","newDepth","previousRootKey","newRootKey","layer","rootJustChanged","kind","appearsAsUnderlay","undefined","disappearsAsUnderlay","startsRootChange"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEO,SAASA,gBAAgBA,CAAC;EAC/BC,eAAe;EACfC,aAAa;EACbC,QAAQ;EACRC,eAAe;EACfC,UAAU;EACVC,KAAK;AACLC,EAAAA;AACF,CAAC,EAAE;AACD,EAAA,IAAIN,eAAe,EAAE;IACnB,OAAO;AAAEO,MAAAA,IAAI,EAAE;KAAO;AACxB,EAAA;AAEA,EAAA,IAAIC,iBAAiB,GAAGH,KAAK,GAAG,CAAC,IAAIH,QAAQ,GAAG,CAAC,IAAID,aAAa,KAAK,CAAC;AACxE,EAAA,IAAIO,iBAAiB,IAAIP,aAAa,KAAKQ,SAAS,EAAE;IACpD,OAAO;AAAEF,MAAAA,IAAI,EAAE;KAAW;AAC5B,EAAA;AAEA,EAAA,IAAIG,oBAAoB,GAAGL,KAAK,GAAG,CAAC,IAAIH,QAAQ,KAAK,CAAC,IAAID,aAAa,GAAG,CAAC;AAC3E,EAAA,IAAIS,oBAAoB,EAAE;IACxB,OAAO;AAAEH,MAAAA,IAAI,EAAE;KAAa;AAC9B,EAAA;EAEA,IAAIH,UAAU,KAAKD,eAAe,EAAE;IAClC,OAAO;AAAEI,MAAAA,IAAI,EAAE,KAAK;AAAEI,MAAAA,gBAAgB,EAAE;KAAM;AAChD,EAAA;EAEA,IAAIT,QAAQ,GAAGD,aAAa,EAAE;IAC5B,OAAO;AAAEM,MAAAA,IAAI,EAAED,eAAe,GAAG,KAAK,GAAG;KAAa;AACxD,EAAA;EACA,IAAIJ,QAAQ,GAAGD,aAAa,EAAE;IAC5B,OAAO;AAAEM,MAAAA,IAAI,EAAED,eAAe,GAAG,KAAK,GAAG;KAAgB;AAC3D,EAAA;EAEA,OAAO;AAAEC,IAAAA,IAAI,EAAE;GAAQ;AACzB;;;;"}

package/dist/utils/waiter-state.js

@@ -0,0 +1,130 @@
+import { buildWaiter } from '@ember/test-waiters';
+
+// `buildWaiter` registers a named waiter globally in `@ember/test-waiters`.
+// Hoist these to module scope so every WaiterState instance shares the same
+// two waiters — without this, each `new WaiterState()` (notably in unit
+// tests) would register a fresh duplicate, accumulating noise in the global
+// waiter registry over a test run.
+const TRANSITION_WAITER = buildWaiter('ember-nav-stack:transition');
+const STACK_WAITER = buildWaiter('ember-nav-stack:stack-update');
+
+// Encapsulates the three test-waiter tokens NavStacks needs to manage
+// (transition, stack-update, initial-render), a counter for currently
+// running transitions, and a single-resolver "wait until idle" promise.
+//
+// State diagram:
+//
+//   Tokens (each independently OPEN or CLOSED):
+//     - transition       opens when runningTransitions goes 0 → 1,
+//                        closes when runningTransitions returns to 0
+//     - stackUpdate      opens on beginStackUpdate (idempotent),
+//                        closes on endStackUpdate
+//     - initialRender    opens once at construction, closes once on
+//                        markInitialRenderComplete (subsequent calls
+//                        are no-ops)
+//
+//   isIdle === all three tokens CLOSED && runningTransitions === 0
+//
+//   whenIdle() returns a Promise that resolves the next time isIdle()
+//   becomes true and maybeResolveIdle() is invoked. Repeat callers
+//   while waiting share one promise.
+//
+// `maybeResolveIdle()` is an explicit method (not auto-called from
+// end*/markX) so the caller can wrap it in `next()` (or any other
+// scheduler) — that defers resolution past the current runloop tick,
+// giving other code in the same tick a chance to start another
+// transition before "idle" is declared.
+class WaiterState {
+  constructor() {
+    this._transitionToken = null;
+    this._stackUpdateToken = null;
+    this._initialRenderToken = STACK_WAITER.beginAsync();
+    this._runningTransitions = 0;
+    this._whenIdlePromise = null;
+    this._whenIdleResolve = null;
+  }
+
+  // Transition counter
+
+  beginTransition() {
+    this._runningTransitions++;
+    if (this._runningTransitions === 1) {
+      this._transitionToken = TRANSITION_WAITER.beginAsync();
+    }
+  }
+  endTransition() {
+    this._runningTransitions--;
+    if (this._runningTransitions < 0) {
+      this._runningTransitions = 0;
+    }
+    if (this._runningTransitions === 0 && this._transitionToken) {
+      TRANSITION_WAITER.endAsync(this._transitionToken);
+      this._transitionToken = null;
+    }
+  }
+  runningTransitions() {
+    return this._runningTransitions;
+  }
+  isRunningTransitions() {
+    return this._runningTransitions > 0;
+  }
+
+  // Stack-update token (coalesced across pushItem/removeItem in one flush)
+
+  beginStackUpdate() {
+    if (!this._stackUpdateToken) {
+      this._stackUpdateToken = STACK_WAITER.beginAsync();
+    }
+  }
+  endStackUpdate() {
+    if (this._stackUpdateToken) {
+      STACK_WAITER.endAsync(this._stackUpdateToken);
+      this._stackUpdateToken = null;
+    }
+  }
+  hasPendingStackUpdate() {
+    return !!this._stackUpdateToken;
+  }
+
+  // Initial-render token (open from construction, closed at most once)
+
+  markInitialRenderComplete() {
+    if (this._initialRenderToken) {
+      STACK_WAITER.endAsync(this._initialRenderToken);
+      this._initialRenderToken = null;
+    }
+  }
+  hasPendingInitialRender() {
+    return !!this._initialRenderToken;
+  }
+
+  // Idle queries + promise
+
+  isIdle() {
+    return this._runningTransitions === 0 && !this._stackUpdateToken && !this._initialRenderToken;
+  }
+  whenIdle() {
+    if (this._whenIdlePromise) {
+      return this._whenIdlePromise;
+    }
+    this._whenIdlePromise = new Promise(resolve => {
+      this._whenIdleResolve = resolve;
+    });
+    return this._whenIdlePromise;
+  }
+
+  // Resolves any outstanding whenIdle() promise if all tokens are closed
+  // and no transitions are running. No-op otherwise. Callers schedule this
+  // via `next()` (or similar) to defer resolution past the current tick.
+  maybeResolveIdle() {
+    if (this.isIdle() && this._whenIdleResolve) {
+      let resolve = this._whenIdleResolve;
+      this._whenIdleResolve = null;
+      this._whenIdlePromise = null;
+      resolve();
+    }
+  }
+}
+
+export { WaiterState as default };
+//# sourceMappingURL=waiter-state.js.map

package/dist/utils/waiter-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"waiter-state.js","sources":["../../src/utils/waiter-state.js"],"sourcesContent":["import { buildWaiter } from '@ember/test-waiters';\n\n// `buildWaiter` registers a named waiter globally in `@ember/test-waiters`.\n// Hoist these to module scope so every WaiterState instance shares the same\n// two waiters — without this, each `new WaiterState()` (notably in unit\n// tests) would register a fresh duplicate, accumulating noise in the global\n// waiter registry over a test run.\nconst TRANSITION_WAITER = buildWaiter('ember-nav-stack:transition');\nconst STACK_WAITER = buildWaiter('ember-nav-stack:stack-update');\n\n// Encapsulates the three test-waiter tokens NavStacks needs to manage\n// (transition, stack-update, initial-render), a counter for currently\n// running transitions, and a single-resolver \"wait until idle\" promise.\n//\n// State diagram:\n//\n//   Tokens (each independently OPEN or CLOSED):\n//     - transition       opens when runningTransitions goes 0 → 1,\n//                        closes when runningTransitions returns to 0\n//     - stackUpdate      opens on beginStackUpdate (idempotent),\n//                        closes on endStackUpdate\n//     - initialRender    opens once at construction, closes once on\n//                        markInitialRenderComplete (subsequent calls\n//                        are no-ops)\n//\n//   isIdle === all three tokens CLOSED && runningTransitions === 0\n//\n//   whenIdle() returns a Promise that resolves the next time isIdle()\n//   becomes true and maybeResolveIdle() is invoked. Repeat callers\n//   while waiting share one promise.\n//\n// `maybeResolveIdle()` is an explicit method (not auto-called from\n// end*/markX) so the caller can wrap it in `next()` (or any other\n// scheduler) — that defers resolution past the current runloop tick,\n// giving other code in the same tick a chance to start another\n// transition before \"idle\" is declared.\nexport default class WaiterState {\n  constructor() {\n    this._transitionToken = null;\n    this._stackUpdateToken = null;\n    this._initialRenderToken = STACK_WAITER.beginAsync();\n    this._runningTransitions = 0;\n    this._whenIdlePromise = null;\n    this._whenIdleResolve = null;\n  }\n\n  // Transition counter\n\n  beginTransition() {\n    this._runningTransitions++;\n    if (this._runningTransitions === 1) {\n      this._transitionToken = TRANSITION_WAITER.beginAsync();\n    }\n  }\n\n  endTransition() {\n    this._runningTransitions--;\n    if (this._runningTransitions < 0) {\n      this._runningTransitions = 0;\n    }\n    if (this._runningTransitions === 0 && this._transitionToken) {\n      TRANSITION_WAITER.endAsync(this._transitionToken);\n      this._transitionToken = null;\n    }\n  }\n\n  runningTransitions() {\n    return this._runningTransitions;\n  }\n\n  isRunningTransitions() {\n    return this._runningTransitions > 0;\n  }\n\n  // Stack-update token (coalesced across pushItem/removeItem in one flush)\n\n  beginStackUpdate() {\n    if (!this._stackUpdateToken) {\n      this._stackUpdateToken = STACK_WAITER.beginAsync();\n    }\n  }\n\n  endStackUpdate() {\n    if (this._stackUpdateToken) {\n      STACK_WAITER.endAsync(this._stackUpdateToken);\n      this._stackUpdateToken = null;\n    }\n  }\n\n  hasPendingStackUpdate() {\n    return !!this._stackUpdateToken;\n  }\n\n  // Initial-render token (open from construction, closed at most once)\n\n  markInitialRenderComplete() {\n    if (this._initialRenderToken) {\n      STACK_WAITER.endAsync(this._initialRenderToken);\n      this._initialRenderToken = null;\n    }\n  }\n\n  hasPendingInitialRender() {\n    return !!this._initialRenderToken;\n  }\n\n  // Idle queries + promise\n\n  isIdle() {\n    return (\n      this._runningTransitions === 0 &&\n      !this._stackUpdateToken &&\n      !this._initialRenderToken\n    );\n  }\n\n  whenIdle() {\n    if (this._whenIdlePromise) {\n      return this._whenIdlePromise;\n    }\n    this._whenIdlePromise = new Promise((resolve) => {\n      this._whenIdleResolve = resolve;\n    });\n    return this._whenIdlePromise;\n  }\n\n  // Resolves any outstanding whenIdle() promise if all tokens are closed\n  // and no transitions are running. No-op otherwise. Callers schedule this\n  // via `next()` (or similar) to defer resolution past the current tick.\n  maybeResolveIdle() {\n    if (this.isIdle() && this._whenIdleResolve) {\n      let resolve = this._whenIdleResolve;\n      this._whenIdleResolve = null;\n      this._whenIdlePromise = null;\n      resolve();\n    }\n  }\n}\n"],"names":["TRANSITION_WAITER","buildWaiter","STACK_WAITER","WaiterState","constructor","_transitionToken","_stackUpdateToken","_initialRenderToken","beginAsync","_runningTransitions","_whenIdlePromise","_whenIdleResolve","beginTransition","endTransition","endAsync","runningTransitions","isRunningTransitions","beginStackUpdate","endStackUpdate","hasPendingStackUpdate","markInitialRenderComplete","hasPendingInitialRender","isIdle","whenIdle","Promise","resolve","maybeResolveIdle"],"mappings":"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"}