@nativescript/angular 21.0.1-alpha.4 → 21.0.1-alpha.6

package/fesm2022/nativescript-angular.mjs

@@ -7447,13 +7447,20 @@ const DEFAULT_INVALIDATE_EVENT = 'ns:cache-invalidate';
  * 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.
+ *
+ * Webpack-CommonJS compatibility: every `import.meta` reference here
+ * is a member expression (`import.meta['hot']`). Webpack statically
+ * rewrites both dot- and bracket-style member access to `undefined`
+ * in CommonJS output, so the emitted bundle never carries a literal
+ * bare `import.meta` token. A bare `import.meta` would survive into
+ * the bundle and crash V8 with "Cannot use 'import.meta' outside a
+ * module" the moment the chunk is `require()`d. Vite leaves
+ * `import.meta['hot']` intact and resolves it to the per-module hot
+ * context, so the same code works in both pipelines.
  */
 function readImportMetaHot() {
     try {
-        const meta = typeof import.meta !== 'undefined'
-            ? import.meta
-            : undefined;
-        return meta?.hot;
+        return import.meta['hot'];
     }
     catch {
         return undefined;
@@ -7879,10 +7886,12 @@ function getOrCreateSharedStore() {
 }
 function hasImportMetaHot() {
     try {
-        const meta = typeof import.meta !== 'undefined'
-            ? import.meta
-            : undefined;
-        return !!meta?.hot;
+        // Member-expression access only — webpack rewrites `import.meta['hot']`
+        // to `undefined` in CommonJS bundles (so `!!undefined` → `false`),
+        // while Vite leaves it as the per-module hot context. A bare
+        // `typeof import.meta` would survive into the bundle and crash V8
+        // with "Cannot use 'import.meta' outside a module" on `require()`.
+        return !!import.meta['hot'];
     }
     catch {
         return false;
@@ -9866,6 +9875,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.
@@ -10157,6 +10185,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;
@@ -10165,6 +10221,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;
         }
@@ -10174,6 +10236,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) {
@@ -10181,7 +10244,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.
@@ -10195,6 +10265,7 @@ class NativeScriptAngularHmrRouteTracker {
                 }
                 this.currentNavigationIsPopstate = false;
                 this.currentNavigationReplaceUrl = false;
+                this.currentNavigationClearsHistory = false;
             }
         });
     }