@nativescript/angular 21.0.1-alpha.3 → 21.0.1-alpha.5

package/fesm2022/nativescript-angular.mjs

@@ -6426,11 +6426,18 @@ let NativeModalRef = class NativeModalRef {
         this._closeCallback = once(async () => {
             this.stateChanged.next({ state: 'closing' });
             if (!this._isDismissed) {
-                this.modalViewRef.firstNativeLikeView?.closeModal();
+                // Prefer `modalView` (the actual presented view) over the
+                // legacy `firstNativeLikeView`. Both paths ultimately reach
+                // the same `_closeModalCallback` via parent walk, but going
+                // through the presented view is one hop instead of three and
+                // works even if the rendered first root has been replaced by
+                // an HMR `ɵɵreplaceMetadata` cycle.
+                const closeTarget = this.modalView ?? this.modalViewRef.firstNativeLikeView;
+                closeTarget?.closeModal();
             }
             await this.location?._closeModalNavigation();
             // this.detachedLoaderRef?.destroy();
-            if (this.modalViewRef?.firstNativeLikeView.isLoaded) {
+            if (this.modalViewRef?.firstNativeLikeView?.isLoaded) {
                 fromEvent(this.modalViewRef.firstNativeLikeView, 'unloaded')
                     .pipe(take(1))
                     .subscribe(() => this.stateChanged.next({ state: 'closed' }));
@@ -6483,19 +6490,34 @@ let NativeModalRef = class NativeModalRef {
     }
     attachComponentPortal(portal) {
         this.startModalNavigation();
+        // `targetView` is a stable ContentView wrapper we own. The Angular
+        // component's host (a `ProxyViewContainer`) is attached as its
+        // content via the portal outlet below. We present `targetView`
+        // itself as the modal — *not* the first rendered template root —
+        // so that component-level HMR (`ɵɵreplaceMetadata`) can re-render
+        // into the PVC and the modal automatically displays the new
+        // content via the wrapper. Presenting the rendered first root
+        // directly worked for the initial open but left subsequent HMR
+        // updates rendering into a detached PVC, producing a blank modal.
         const targetView = new ContentView();
         this.portalOutlet = new NativeScriptDomPortalOutlet(targetView, this._config.componentFactoryResolver || this._injector.get(ComponentFactoryResolver), this._injector.get(ApplicationRef), this._injector);
         const componentRef = this.portalOutlet.attach(portal);
         componentRef.changeDetectorRef.detectChanges();
         this.modalViewRef = new NgViewRef(componentRef);
+        this.modalView = targetView;
         if (this.modalViewRef.firstNativeLikeView !== this.modalViewRef.view) {
             this.modalViewRef.view._ngDialogRoot = this.modalViewRef.firstNativeLikeView;
         }
-        this.modalViewRef.firstNativeLikeView['__ng_modal_id__'] = this._id;
-        // if we don't detach the view from its parent, ios gets mad
-        this.modalViewRef.detachNativeLikeView();
+        // Tag both the wrapper (the actual modal root) and the rendered
+        // first root so `getClosestDialog`'s parent walk finds the modal
+        // id regardless of whether it starts from a view inside the
+        // template or from the wrapper.
+        targetView['__ng_modal_id__'] = this._id;
+        if (this.modalViewRef.firstNativeLikeView) {
+            this.modalViewRef.firstNativeLikeView['__ng_modal_id__'] = this._id;
+        }
         const userOptions = this._config.nativeOptions || {};
-        this.parentView.showModal(this.modalViewRef.firstNativeLikeView, {
+        this.parentView.showModal(targetView, {
             context: null,
             ...userOptions,
             closeCallback: async () => {
@@ -7360,6 +7382,513 @@ function generateNativeScriptView(typeOrTemplate, options) {
     return viewRef;
 }
 
+/**
+ * Framework-agnostic Hot-Module-Replacement state cache.
+ *
+ * The {@link HmrCacheStore} class is intentionally free of any Angular
+ * imports so a future `@nativescript/solid` (or any other framework
+ * binding) can lift this file as-is and wrap it with its own DI
+ * primitive. The Angular DI wrapper lives in
+ * `./hmr-cache.service.ts`.
+ *
+ * # What it does
+ *
+ * The NativeScript iOS runtime exposes a Vite-spec compliant
+ * `import.meta.hot` on every imported module (see
+ * `@nativescript/ios` →
+ * `runtime/HMRSupport.{h,mm}::InitializeImportMetaHot`). The runtime
+ * keeps a per-module persistent `data` object alive in C++ across V8
+ * evaluation cycles and canonicalizes the module path so the same
+ * bucket survives the URL variations Vite cycles through during a
+ * save (HMR boot/live tags, versioned bridge paths, common script
+ * extensions). When `@nativescript/vite`'s Angular HMR client calls
+ * `globalThis.__nsRunHmrDispose()` before `__reboot_ng_modules__`,
+ * every registered `dispose(cb)` fires and is handed the same `data`
+ * object the next module evaluation will read from.
+ *
+ * `HmrCacheStore` rides on top of that primitive:
+ *
+ *   1. On construction, it copies any previously-stashed entries out
+ *      of `import.meta.hot.data['ns-hmr-cache']` (or whatever
+ *      `storageKey` the caller picked) into an in-memory `Map`.
+ *   2. It registers a single `import.meta.hot.dispose` callback that
+ *      writes the in-memory `Map` back as a plain object before the
+ *      next reboot.
+ *   3. Every `set` re-orders the key to the end of the `Map` (LRU);
+ *      when `size > maxEntries`, the oldest entry is evicted. This
+ *      stops a long dev session from accumulating unbounded state for
+ *      features the developer no longer touches.
+ *   4. It subscribes to a custom HMR event (default
+ *      `'ns:cache-invalidate'`) so a Vite plugin or dev server can
+ *      push targeted cache evictions — e.g. "the OData schema for
+ *      `/safety/forms` changed, drop anything that depends on it".
+ *
+ * In production / `--no-hmr` builds `import.meta.hot` is `undefined`,
+ * the store collapses to a pure in-memory cache that lives for the
+ * lifetime of the process, and the public API is identical so callers
+ * never need to special-case build modes.
+ *
+ * # Why a class and not a plain object
+ *
+ * Encapsulating the LRU bookkeeping behind named methods (`get`,
+ * `set`, `invalidate`, `scope`) lets us evolve the eviction policy
+ * (e.g. add TTLs, weighted entries, structured-clone enforcement)
+ * without touching every call site. The framework wrappers expose
+ * the same surface so app authors learn one API regardless of which
+ * framework they use.
+ */
+const DEFAULT_MAX_ENTRIES = 256;
+const DEFAULT_STORAGE_KEY = 'ns-hmr-cache';
+const DEFAULT_INVALIDATE_EVENT = 'ns:cache-invalidate';
+/**
+ * Read `import.meta.hot` defensively so the package compiles even
+ * under TypeScript configs that don't extend an `ImportMeta` interface
+ * with a `hot` field. The cast goes through `unknown` so the local
+ * type is the only one in play; `vite/client`-aware apps still get
+ * their own typing on `import.meta.hot` at every call site outside
+ * this module.
+ */
+function readImportMetaHot() {
+    try {
+        const meta = typeof import.meta !== 'undefined'
+            ? import.meta
+            : undefined;
+        return meta?.hot;
+    }
+    catch {
+        return undefined;
+    }
+}
+class HmrCacheStore {
+    /**
+     * @param initialEntries Entries to seed the store with (typically
+     *   the previous session's snapshot read from
+     *   `import.meta.hot.data`).
+     * @param options See {@link HmrCacheStoreOptions}.
+     */
+    constructor(initialEntries = [], options = {}) {
+        this._map = new Map(initialEntries);
+        const requested = options.maxEntries;
+        this._maxEntries =
+            typeof requested === 'number' && requested > 0
+                ? Math.floor(requested)
+                : 0;
+        this._log = options.log ?? (() => { });
+        // Trim seed if it overshoots the configured ceiling — possible if
+        // a previous session ran with a larger `maxEntries` than this one.
+        this._enforceMaxEntries();
+    }
+    get(key) {
+        if (!this._map.has(key)) {
+            return undefined;
+        }
+        // LRU touch: re-insert so the entry moves to the end of the
+        // insertion-order Map.
+        const value = this._map.get(key);
+        this._map.delete(key);
+        this._map.set(key, value);
+        return value;
+    }
+    set(key, value) {
+        if (this._map.has(key)) {
+            // Delete-then-set keeps insertion order monotonic.
+            this._map.delete(key);
+        }
+        this._map.set(key, value);
+        this._enforceMaxEntries();
+    }
+    has(key) {
+        return this._map.has(key);
+    }
+    delete(key) {
+        this._map.delete(key);
+    }
+    /**
+     * Drop a specific entry, or every entry when `key` is omitted.
+     * Equivalent to {@link delete} (with key) or {@link clear} (without)
+     * — exposed as a single method so callers and event handlers can
+     * forward an optional key without branching.
+     */
+    invalidate(key) {
+        if (key === undefined || key === null) {
+            this.clear();
+            return;
+        }
+        this.delete(key);
+    }
+    /** Drop every cached entry. */
+    clear() {
+        this._map.clear();
+    }
+    /** Total number of cached entries across all scopes. */
+    size() {
+        return this._map.size;
+    }
+    /** Snapshot of every key currently in the cache. */
+    keys() {
+        return Array.from(this._map.keys());
+    }
+    /**
+     * Returns a namespaced view of this store. All keys passed to the
+     * returned object are auto-prefixed with `<prefix>:`. Useful so
+     * each feature module can avoid stomping on neighbours' keys
+     * without repeating the prefix at every call site.
+     *
+     * @example
+     * ```ts
+     * const cache = createDefaultHmrCacheStore();
+     * const submissions = cache.scope('page-my-submissions');
+     * submissions.set('items', [...]); // stored under 'page-my-submissions:items'
+     * ```
+     */
+    scope(prefix) {
+        if (!prefix) {
+            throw new Error('[HmrCacheStore] scope() requires a non-empty prefix');
+        }
+        const fullPrefix = `${prefix}:`;
+        const parent = this;
+        return {
+            prefix: fullPrefix,
+            get(key) {
+                return parent.get(fullPrefix + key);
+            },
+            set(key, value) {
+                parent.set(fullPrefix + key, value);
+            },
+            has(key) {
+                return parent.has(fullPrefix + key);
+            },
+            delete(key) {
+                parent.delete(fullPrefix + key);
+            },
+            clear() {
+                for (const k of parent.keys()) {
+                    if (k.startsWith(fullPrefix)) {
+                        parent.delete(k);
+                    }
+                }
+            },
+            size() {
+                let n = 0;
+                for (const k of parent.keys()) {
+                    if (k.startsWith(fullPrefix)) {
+                        n++;
+                    }
+                }
+                return n;
+            },
+        };
+    }
+    /**
+     * Serialize every entry into a plain object suitable for stashing
+     * on `import.meta.hot.data`. Used by the dispose callback in
+     * {@link createDefaultHmrCacheStore} and re-exported for callers
+     * that want to integrate with another persistence layer (e.g. a
+     * test harness that snapshots between cases).
+     */
+    toObject() {
+        const out = {};
+        for (const [k, v] of this._map.entries()) {
+            out[k] = v;
+        }
+        return out;
+    }
+    _enforceMaxEntries() {
+        if (this._maxEntries <= 0) {
+            return;
+        }
+        while (this._map.size > this._maxEntries) {
+            const oldestKey = this._map.keys().next().value;
+            if (oldestKey === undefined) {
+                return;
+            }
+            this._map.delete(oldestKey);
+            this._log(`[HmrCacheStore] evicted oldest key="${oldestKey}" (size now ${this._map.size}/${this._maxEntries})`);
+        }
+    }
+}
+/**
+ * Build an {@link HmrCacheStore} bound to the current module's
+ * `import.meta.hot` context — i.e. the store's data survives HMR
+ * reboots and listens for the `'ns:cache-invalidate'` custom event.
+ *
+ * Caller responsibility: invoke this from the module that "owns" the
+ * cache. `import.meta` is per-module, so the dispose callback will be
+ * registered against whichever module physically calls this function.
+ * In `@nativescript/angular` the canonical owner is
+ * `hmr-cache.service.ts`; in `@nativescript/solid` it would be the
+ * equivalent solid-side module.
+ *
+ * Returns a freshly-constructed store. Callers should treat it as a
+ * singleton — calling this twice from the same module yields two
+ * independent stores, which is almost never what you want.
+ */
+function createDefaultHmrCacheStore(options = {}) {
+    const storageKey = options.storageKey ?? DEFAULT_STORAGE_KEY;
+    const invalidateEventName = options.invalidateEventName ?? DEFAULT_INVALIDATE_EVENT;
+    const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    const log = options.log ?? (() => { });
+    const hot = readImportMetaHot();
+    // Read previous session's snapshot (if any) and seed the store.
+    const previousSnapshot = (hot?.data?.[storageKey] ?? {});
+    const previousEntries = Object.entries(previousSnapshot);
+    const store = new HmrCacheStore(previousEntries, {
+        maxEntries,
+        storageKey,
+        invalidateEventName,
+        log,
+    });
+    if (hot) {
+        if (previousEntries.length) {
+            log(`[HmrCacheStore] rehydrated ${previousEntries.length} entr${previousEntries.length === 1 ? 'y' : 'ies'} from previous HMR session (storageKey="${storageKey}")`);
+        }
+        // Stash the live store back on dispose so the next reboot finds
+        // exactly what's in memory right now.
+        hot.dispose((data) => {
+            const snapshot = store.toObject();
+            data[storageKey] = snapshot;
+            log(`[HmrCacheStore] dispose stashed ${Object.keys(snapshot).length} entr${Object.keys(snapshot).length === 1 ? 'y' : 'ies'} (storageKey="${storageKey}")`);
+        });
+        // Listen for server-side invalidation events. Vite plugins push
+        // these via `server.ws.send({ type: 'custom', event: 'ns:cache-invalidate', data: { key? } })`.
+        // The HMR client forwards them to `import.meta.hot.on`. If the
+        // runtime doesn't expose `on` (older `@nativescript/ios`), this
+        // is a clean no-op.
+        if (typeof hot.on === 'function') {
+            hot.on(invalidateEventName, (payload) => {
+                const targetKey = payload?.key;
+                store.invalidate(targetKey);
+                log(targetKey
+                    ? `[HmrCacheStore] server-side invalidate dropped key="${targetKey}"`
+                    : `[HmrCacheStore] server-side invalidate cleared all entries`);
+            });
+        }
+    }
+    return store;
+}
+
+/**
+ * Skip the API call your component already paid for last save.
+ *
+ * Inject {@link HmrCacheService} from any Angular component or service
+ * to read and write a per-app key/value cache that **survives the
+ * `__reboot_ng_modules__` cycle** triggered by every HMR file save.
+ * Backed by `@nativescript/ios`'s native `import.meta.hot.data`
+ * (`runtime/HMRSupport.{h,mm}`) and drained via
+ * `@nativescript/vite`'s `globalThis.__nsRunHmrDispose()` hook before
+ * Angular tears down its realm, so the same value the previous
+ * component instance produced is handed straight to the freshly-
+ * instantiated one — no network round-trip, no spinner flash.
+ *
+ * In production / `--no-hmr` builds `import.meta.hot` is `undefined`
+ * and the cache collapses to a plain in-memory object that lives for
+ * the lifetime of the process. The public API is identical, so callers
+ * never need to special-case build modes.
+ *
+ * @example Skip the initial fetch on save
+ * ```ts
+ * import { HmrCacheService } from '@nativescript/angular';
+ *
+ * @Component({...})
+ * export class MyComponent implements OnInit {
+ *   private hmrCache = inject(HmrCacheService);
+ *
+ *   ngOnInit() {
+ *     const cached = this.hmrCache.get<MyResult>('my-feature:items');
+ *     if (cached) {
+ *       this.applyResult(cached);
+ *       return;
+ *     }
+ *     this.api.load().subscribe((result) => {
+ *       this.hmrCache.set('my-feature:items', result);
+ *       this.applyResult(result);
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @example Namespaced via {@link scope}
+ * ```ts
+ * private cache = inject(HmrCacheService).scope('page-my-submissions');
+ * // …
+ * this.cache.set('items', items);   // → 'page-my-submissions:items'
+ * this.cache.get('items');          // ← 'page-my-submissions:items'
+ * ```
+ *
+ * @example Server-side invalidation from a Vite plugin
+ * ```ts
+ * // vite.config.ts
+ * export default defineConfig({
+ *   plugins: [
+ *     {
+ *       name: 'my-schema-watcher',
+ *       configureServer(server) {
+ *         server.watcher.on('change', (path) => {
+ *           if (path.endsWith('schema.json')) {
+ *             server.ws.send({
+ *               type: 'custom',
+ *               event: 'ns:cache-invalidate',
+ *               data: { key: 'my-feature:items' },
+ *             });
+ *           }
+ *         });
+ *       },
+ *     },
+ *   ],
+ * });
+ * ```
+ *
+ * Memory ceiling: the cache LRU-evicts at 256 entries by default. Pass
+ * a custom ceiling via {@link configureHmrCache} if your app churns
+ * through more keys than that in a typical dev session, or set `0` for
+ * unlimited (unbounded growth — only safe for short-lived dev work).
+ *
+ * @see HmrCacheStore — the framework-agnostic engine. Stable enough to
+ *   lift into `@nativescript/solid` / other framework bindings without
+ *   modification.
+ */
+class HmrCacheService {
+    constructor() {
+        this._store = getOrCreateSharedStore();
+        /**
+         * `true` when `import.meta.hot` is wired (i.e. NativeScript Vite HMR
+         * is active and `@nativescript/ios` is recent enough to expose
+         * `import.meta.hot.data`). `false` in production / `--no-hmr` /
+         * legacy webpack builds.
+         *
+         * Most callers should NOT branch on this — the public API works
+         * identically in both cases. Use it only when you want to opt OUT
+         * of caching in production (e.g. always fetch fresh data when not
+         * developing).
+         */
+        this.isHmr = isAngularHmrEnabled() && hasImportMetaHot();
+    }
+    get(key) {
+        return this._store.get(key);
+    }
+    set(key, value) {
+        this._store.set(key, value);
+    }
+    has(key) {
+        return this._store.has(key);
+    }
+    delete(key) {
+        this._store.delete(key);
+    }
+    /**
+     * Drop a single entry, or every entry when `key` is omitted. Same
+     * shape as the `'ns:cache-invalidate'` HMR-event payload the store
+     * listens for, so application code can call this directly to mirror
+     * a server-side eviction.
+     */
+    invalidate(key) {
+        this._store.invalidate(key);
+    }
+    /** Drop every cached entry. Equivalent to `invalidate()` with no key. */
+    clear() {
+        this._store.clear();
+    }
+    /** Total number of entries across every scope. */
+    size() {
+        return this._store.size();
+    }
+    /** Snapshot of every key currently cached. Useful for debug overlays. */
+    keys() {
+        return this._store.keys();
+    }
+    /**
+     * Returns a namespaced view of the cache. All `get` / `set` /
+     * `has` / `delete` calls on the returned object are auto-prefixed
+     * with `<scopeName>:`. Recommended over global keys so feature
+     * modules don't accidentally collide.
+     *
+     * @example
+     * ```ts
+     * private cache = inject(HmrCacheService).scope('page-my-submissions');
+     * // …
+     * this.cache.set('items', items); // → 'page-my-submissions:items'
+     * ```
+     */
+    scope(scopeName) {
+        return this._store.scope(scopeName);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: HmrCacheService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: HmrCacheService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: HmrCacheService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+/**
+ * Override the default cache configuration. Must be called BEFORE the
+ * first injection of {@link HmrCacheService} (i.e. before Angular
+ * bootstrap, or as the very first statement in `main.ts`); otherwise
+ * the call is a no-op because the singleton store has already been
+ * built with the previous (or default) options.
+ *
+ * Typical use case: bumping `maxEntries` for a large multi-feature
+ * monorepo dev session, or pointing a custom `invalidateEventName` at
+ * a Vite plugin that prefixes its events with the project name.
+ *
+ * Returns `true` if the configuration was applied, `false` if the
+ * store had already been instantiated by an earlier injection.
+ */
+function configureHmrCache(options) {
+    if (sharedStore !== null) {
+        return false;
+    }
+    pendingOptions = options;
+    return true;
+}
+/**
+ * Read-only access to the underlying {@link HmrCacheStore}. Exposed
+ * for advanced integrations that want to reuse the LRU + dispose +
+ * server-side-invalidate plumbing without going through Angular's
+ * dependency injection (e.g. a non-component utility that's loaded
+ * before the Angular platform has bootstrapped). Application code
+ * should prefer {@link HmrCacheService}.
+ */
+function getHmrCacheStore() {
+    return getOrCreateSharedStore();
+}
+let sharedStore = null;
+let pendingOptions = null;
+function getOrCreateSharedStore() {
+    if (sharedStore !== null) {
+        return sharedStore;
+    }
+    const options = {
+        log: (msg) => {
+            // Keep cache diagnostics on the same channel as other HMR
+            // helpers so devs can grep one trace category and see the full
+            // picture during a save cycle. NativeScriptDebug.bootstrapLog
+            // is the conventional sink for HMR-adjacent lifecycle logs.
+            try {
+                NativeScriptDebug.bootstrapLog(msg);
+            }
+            catch {
+                // Defensive: never crash the cache if the trace channel is
+                // unavailable (e.g. tests that import this file in isolation).
+            }
+        },
+        ...pendingOptions,
+    };
+    sharedStore = createDefaultHmrCacheStore(options);
+    pendingOptions = null;
+    return sharedStore;
+}
+function hasImportMetaHot() {
+    try {
+        const meta = typeof import.meta !== 'undefined'
+            ? import.meta
+            : undefined;
+        return !!meta?.hot;
+    }
+    catch {
+        return false;
+    }
+}
+
 class BaseValueAccessor {
     constructor(view) {
         this.view = view;
@@ -9337,6 +9866,25 @@ function clearAngularHmrRouteHistory() {
     const g = getGlobalState();
     delete g[HISTORY_KEY];
 }
+/**
+ * Replace the entire live back-stack mirror with a single URL. Mirrors
+ * NativeScript's `clearHistory: true` navigation option, which collapses
+ * the native page stack down to the destination — without this, the HMR
+ * snapshot would still carry every URL the user passed through before
+ * the reset (e.g. login screens that auth-gates now hide), and the next
+ * reboot would walk through every one of them as a forward navigation.
+ *
+ * An empty / unparseable `value` clears the mirror entirely.
+ */
+function resetAngularHmrRouteHistoryToUrl(value) {
+    const url = normalizeAngularHmrRouteUrl(value);
+    if (!url) {
+        writeHistoryArray(HISTORY_KEY, []);
+        return null;
+    }
+    writeHistoryArray(HISTORY_KEY, [url]);
+    return url;
+}
 /**
  * Snapshot the live back-stack mirror under the pending-history slot so the
  * next bootstrap can read it. Called from the HMR capture hook.
@@ -9628,6 +10176,34 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.9", ngImpor
             type: Injectable
         }], ctorParameters: () => [{ type: i1$3.Router }] });
 
+/**
+ * Read NativeScript's `clearHistory: true` navigation extra off the active
+ * Angular navigation. Defensive against test mocks and bare `Router`-like
+ * shapes that don't expose `getCurrentNavigation` (e.g. earlier Angular
+ * versions and the unit-test mocks in `hmr-route-state-tracker.spec.ts`).
+ *
+ * `clearHistory` is the NativeScript-only signal that
+ * `NSLocationStrategy._beginPageNavigation` uses to collapse the native page
+ * stack down to the destination. We mirror that on the HMR side so a
+ * subsequent reboot doesn't replay URLs the user can no longer reach (the
+ * canonical example: `/`, `/signup-landing`, `/login` after the auth flow
+ * navigated to `/talk/(todayTab:today)` with `clearHistory: true`).
+ */
+function readClearHistoryFromRouter(router) {
+    const getCurrentNavigation = router.getCurrentNavigation;
+    if (typeof getCurrentNavigation !== 'function') {
+        return false;
+    }
+    let navigation;
+    try {
+        navigation = getCurrentNavigation.call(router);
+    }
+    catch {
+        return false;
+    }
+    const extras = navigation?.extras;
+    return !!extras?.clearHistory;
+}
 class NativeScriptAngularHmrRouteTracker {
     constructor(router) {
         this.router = router;
@@ -9636,6 +10212,12 @@ class NativeScriptAngularHmrRouteTracker {
         // `NavigationEnd` we can pop our mirror instead of pushing a duplicate entry.
         this.currentNavigationIsPopstate = false;
         this.currentNavigationReplaceUrl = false;
+        // Tracks whether the active navigation was started with NativeScript's
+        // `clearHistory: true` extra (read off `router.getCurrentNavigation()` at
+        // `NavigationStart`). When set, the matching `NavigationEnd` collapses the
+        // mirror down to just the destination URL — see
+        // `resetAngularHmrRouteHistoryToUrl` for the rationale.
+        this.currentNavigationClearsHistory = false;
         if (!isAngularHmrEnabled()) {
             return;
         }
@@ -9645,6 +10227,7 @@ class NativeScriptAngularHmrRouteTracker {
             if (event instanceof NavigationStart) {
                 this.currentNavigationIsPopstate = event.navigationTrigger === 'popstate';
                 this.currentNavigationReplaceUrl = !!event.restoredState;
+                this.currentNavigationClearsHistory = readClearHistoryFromRouter(this.router);
                 return;
             }
             if (event instanceof NavigationEnd) {
@@ -9652,7 +10235,14 @@ class NativeScriptAngularHmrRouteTracker {
                 writeAngularHmrRouteState(url, {
                     source: 'navigation-end',
                 });
-                if (this.currentNavigationIsPopstate) {
+                if (this.currentNavigationClearsHistory) {
+                    // NativeScript collapsed the native page stack to this single
+                    // destination. Mirror that on the HMR side so a future reboot
+                    // replays only what the user can still navigate back through —
+                    // not every URL they passed through before the reset.
+                    resetAngularHmrRouteHistoryToUrl(url);
+                }
+                else if (this.currentNavigationIsPopstate) {
                     // The user (or NSLocationStrategy.back()) walked the back-stack down
                     // by one page; mirror that by dropping the top of our snapshot so a
                     // subsequent HMR reboot doesn't carry the popped page back into view.
@@ -9666,6 +10256,7 @@ class NativeScriptAngularHmrRouteTracker {
                 }
                 this.currentNavigationIsPopstate = false;
                 this.currentNavigationReplaceUrl = false;
+                this.currentNavigationClearsHistory = false;
             }
         });
     }
@@ -10188,5 +10779,5 @@ function provideNativeScriptNgZone(options) {
  * Generated bundle index. Do not edit.
  */
 
-export { APP_ROOT_VIEW, ActionBarComponent, ActionBarScope, ActionItemDirective, AndroidFilterComponent, AppHostAsyncView, AppHostView, AppleFilterComponent, BasePortalOutlet, BaseValueAccessor, COMMON_PROVIDERS, CdkPortal, CdkPortalOutlet, CheckedValueAccessor, CommentNode, ComponentPortal, DEVICE, DISABLE_ROOT_VIEW_HANDLING, DateValueAccessor, DetachedLoader, DomPortal, ENABLE_REUSABE_VIEWS, EmulatedRenderer, FrameDirective, FramePageComponent, FramePageModule, FrameService, IOSFilterComponent, InjectableAnimationEngine, InvisibleNode, ItemContext, ListViewComponent, ModalDialogParams, ModalDialogService, NAMESPACE_FILTERS, NATIVESCRIPT_MODULE_PROVIDERS, NATIVESCRIPT_MODULE_STATIC_PROVIDERS, NATIVESCRIPT_ROOT_MODULE_ID, NATIVE_DIALOG_DATA, NATIVE_DIALOG_DEFAULT_OPTIONS, NSEmptyOutletComponent, NSFileSystem, NSLocationStrategy, NSRouteReuseStrategy, NSRouterLink, NSRouterLinkActive, NativeDialog, NativeDialogCloseDirective, NativeDialogConfig, NativeDialogModule, NativeDialogRef, NativeDialog as NativeDialogService, NativeModalRef, NativeScriptAnimationDriver, NativeScriptAnimationPlayer, NativeScriptAnimationsModule, NativeScriptCommonModule, NativeScriptDocument, NativeScriptDomPortalOutlet, NativeScriptFormsModule, NativeScriptHttpClientModule, NativeScriptLoadingService, NativeScriptModule, NativeScriptNgSafeEvent, NativeScriptNgZone, NativeScriptRendererFactory, NativeScriptRendererHelperService, NativeScriptRouterModule, NativeScriptSanitizer, NativescriptXhrFactory, NavigationButtonDirective, NgViewRef, NsHttpBackEnd, NsTemplatedItem, NumberValueAccessor, Outlet, PAGE_FACTORY, PREVENT_CHANGE_EVENTS_DURING_CD, PREVENT_SPECIFIC_EVENTS_DURING_CD, PageDirective, PageRoute, PageRouterOutlet, PageService, PlatformNamespaceFilter, Portal, PortalModule, RootCompositeModule, RootViewProxy, RouterExtensions, START_PATH, SelectedIndexValueAccessor, TEMPLATED_ITEMS_COMPONENT, TabViewDirective, TabViewItemDirective, TemplateKeyDirective, TemplatePortal, TextNode, TextValueAccessor, TimeValueAccessor, VisionOSFilterComponent, bootstrapApplication, createKeyframeAnimation, customFrameComponentFactory, customFrameDirectiveFactory, customPageFactory, customPageFactoryFromFrame, dashCaseToCamelCase, defaultNavOptions, defaultPageFactory, defaultPageFactoryProvider, detachViewFromParent, disableRootViewHanding, errorHandler, extractSingleViewRecursive, frameMeta, generateDetachedLoader, generateFallbackRootView, generateNativeScriptView, generateRandomId, generateRootLayoutAndProxy, getAngularHmrRestoringRoute, getFirstNativeLikeView, getItemViewRoot, getSingleViewRecursive, getViewClass, getViewMeta, instantiateDefaultStyleNormalizer, instantiateSupportedAnimationDriver, isAngularHmrRestoringRoute, isBlank, isContentView, isDetachedElement, isInvisibleNode, isJsObject, isKnownView, isLayout, isListLikeIterable, isPresent, isView, onAfterLivesync, onBeforeLivesync, once, platformNativeScript, platformNativeScriptDynamic, postAngularBootstrap$, preAngularDisposal$, provideLocationStrategy, provideNativeScriptHttpClient, provideNativeScriptNgZone, provideNativeScriptRouter, registerElement, registerNativeScriptViewComponents, rootRoute, runNativeScriptAngularApp, throwIfAlreadyLoaded, throwNoPortalAttachedError, throwNullPortalError, throwNullPortalOutletError, throwPortalAlreadyAttachedError, throwPortalOutletAlreadyDisposedError, throwUnknownPortalTypeError, COMPONENT_VARIABLE as ɵCOMPONENT_VARIABLE, CONTENT_ATTR as ɵCONTENT_ATTR, HOST_ATTR as ɵHOST_ATTR, NativeScriptDebug as ɵNativeScriptAngularDebug, viewUtil as ɵViewUtil, actionBarMeta as ɵactionBarMeta, elementMap as ɵelementMap, isActionItem as ɵisActionItem, isNavigationButton as ɵisNavigationButton };
+export { APP_ROOT_VIEW, ActionBarComponent, ActionBarScope, ActionItemDirective, AndroidFilterComponent, AppHostAsyncView, AppHostView, AppleFilterComponent, BasePortalOutlet, BaseValueAccessor, COMMON_PROVIDERS, CdkPortal, CdkPortalOutlet, CheckedValueAccessor, CommentNode, ComponentPortal, DEVICE, DISABLE_ROOT_VIEW_HANDLING, DateValueAccessor, DetachedLoader, DomPortal, ENABLE_REUSABE_VIEWS, EmulatedRenderer, FrameDirective, FramePageComponent, FramePageModule, FrameService, HmrCacheService, HmrCacheStore, IOSFilterComponent, InjectableAnimationEngine, InvisibleNode, ItemContext, ListViewComponent, ModalDialogParams, ModalDialogService, NAMESPACE_FILTERS, NATIVESCRIPT_MODULE_PROVIDERS, NATIVESCRIPT_MODULE_STATIC_PROVIDERS, NATIVESCRIPT_ROOT_MODULE_ID, NATIVE_DIALOG_DATA, NATIVE_DIALOG_DEFAULT_OPTIONS, NSEmptyOutletComponent, NSFileSystem, NSLocationStrategy, NSRouteReuseStrategy, NSRouterLink, NSRouterLinkActive, NativeDialog, NativeDialogCloseDirective, NativeDialogConfig, NativeDialogModule, NativeDialogRef, NativeDialog as NativeDialogService, NativeModalRef, NativeScriptAnimationDriver, NativeScriptAnimationPlayer, NativeScriptAnimationsModule, NativeScriptCommonModule, NativeScriptDocument, NativeScriptDomPortalOutlet, NativeScriptFormsModule, NativeScriptHttpClientModule, NativeScriptLoadingService, NativeScriptModule, NativeScriptNgSafeEvent, NativeScriptNgZone, NativeScriptRendererFactory, NativeScriptRendererHelperService, NativeScriptRouterModule, NativeScriptSanitizer, NativescriptXhrFactory, NavigationButtonDirective, NgViewRef, NsHttpBackEnd, NsTemplatedItem, NumberValueAccessor, Outlet, PAGE_FACTORY, PREVENT_CHANGE_EVENTS_DURING_CD, PREVENT_SPECIFIC_EVENTS_DURING_CD, PageDirective, PageRoute, PageRouterOutlet, PageService, PlatformNamespaceFilter, Portal, PortalModule, RootCompositeModule, RootViewProxy, RouterExtensions, START_PATH, SelectedIndexValueAccessor, TEMPLATED_ITEMS_COMPONENT, TabViewDirective, TabViewItemDirective, TemplateKeyDirective, TemplatePortal, TextNode, TextValueAccessor, TimeValueAccessor, VisionOSFilterComponent, bootstrapApplication, configureHmrCache, createDefaultHmrCacheStore, createKeyframeAnimation, customFrameComponentFactory, customFrameDirectiveFactory, customPageFactory, customPageFactoryFromFrame, dashCaseToCamelCase, defaultNavOptions, defaultPageFactory, defaultPageFactoryProvider, detachViewFromParent, disableRootViewHanding, errorHandler, extractSingleViewRecursive, frameMeta, generateDetachedLoader, generateFallbackRootView, generateNativeScriptView, generateRandomId, generateRootLayoutAndProxy, getAngularHmrRestoringRoute, getFirstNativeLikeView, getHmrCacheStore, getItemViewRoot, getSingleViewRecursive, getViewClass, getViewMeta, instantiateDefaultStyleNormalizer, instantiateSupportedAnimationDriver, isAngularHmrRestoringRoute, isBlank, isContentView, isDetachedElement, isInvisibleNode, isJsObject, isKnownView, isLayout, isListLikeIterable, isPresent, isView, onAfterLivesync, onBeforeLivesync, once, platformNativeScript, platformNativeScriptDynamic, postAngularBootstrap$, preAngularDisposal$, provideLocationStrategy, provideNativeScriptHttpClient, provideNativeScriptNgZone, provideNativeScriptRouter, registerElement, registerNativeScriptViewComponents, rootRoute, runNativeScriptAngularApp, throwIfAlreadyLoaded, throwNoPortalAttachedError, throwNullPortalError, throwNullPortalOutletError, throwPortalAlreadyAttachedError, throwPortalOutletAlreadyDisposedError, throwUnknownPortalTypeError, COMPONENT_VARIABLE as ɵCOMPONENT_VARIABLE, CONTENT_ATTR as ɵCONTENT_ATTR, HOST_ATTR as ɵHOST_ATTR, NativeScriptDebug as ɵNativeScriptAngularDebug, viewUtil as ɵViewUtil, actionBarMeta as ɵactionBarMeta, elementMap as ɵelementMap, isActionItem as ɵisActionItem, isNavigationButton as ɵisNavigationButton };
 //# sourceMappingURL=nativescript-angular.mjs.map