@nativescript/vite 8.0.0-alpha.34 → 8.0.0-alpha.35

package/hmr/client/index.js

@@ -41,7 +41,11 @@ try {
     }
 }
 catch { }
-const APP_ROOT_VIRTUAL = typeof __NS_APP_ROOT_VIRTUAL__ === 'string' && __NS_APP_ROOT_VIRTUAL__ ? __NS_APP_ROOT_VIRTUAL__ : '/src';
+// Define substitution does NOT reach this file (served raw from node_modules),
+// so prefer the globalThis seed planted by the entry's defines-seed module —
+// the '/src' literal is a last-resort default and is WRONG for 'app/'-rooted
+// projects.
+const APP_ROOT_VIRTUAL = (typeof __NS_APP_ROOT_VIRTUAL__ === 'string' && __NS_APP_ROOT_VIRTUAL__) || (typeof globalThis.__NS_APP_ROOT_VIRTUAL__ === 'string' && globalThis.__NS_APP_ROOT_VIRTUAL__) || '/src';
 const APP_VIRTUAL_WITH_SLASH = APP_ROOT_VIRTUAL.endsWith('/') ? APP_ROOT_VIRTUAL : `${APP_ROOT_VIRTUAL}/`;
 const APP_MAIN_ENTRY_SPEC = `${APP_VIRTUAL_WITH_SLASH}app.ts`;
 // Policy: by default, let the app's own main entry mount initially; HMR client handles updates/remounts only.
@@ -777,6 +781,184 @@ try {
     globalThis.__nsNavigateUsingApp = __nsNavigateUsingApp;
 }
 catch { }
+const openModalRecords = [];
+let modalTrackingInstalled = false;
+/**
+ * Map a served/graph module id (e.g. `/app/modal-page.xml`) to its app-root
+ * relative path (`modal-page.xml`). Single mapping point — the raw-asset
+ * re-registration, page-navigation targets, and modal matching all derive
+ * from this; keep them in sync by construction.
+ */
+function toAppRelativePath(id) {
+    try {
+        const spec = normalizeSpec(id);
+        const appVirtual = APP_VIRTUAL_WITH_SLASH.replace(/^\//, '');
+        let relPath = spec.startsWith('/') ? spec.slice(1) : spec;
+        if (relPath.startsWith(appVirtual))
+            relPath = relPath.slice(appVirtual.length);
+        return relPath || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** App-root relative module name (no extension) for page-shaped files, else null. */
+function toAppModuleName(id) {
+    const relPath = toAppRelativePath(id);
+    if (!relPath || !/\.(xml|ts|js)$/i.test(relPath))
+        return null;
+    return relPath.replace(/\.(xml|ts|js)$/i, '');
+}
+function ensureModalTracking() {
+    if (modalTrackingInstalled)
+        return;
+    try {
+        const View = getCore('View') || globalThis.View;
+        const proto = View?.prototype;
+        if (!proto || typeof proto.showModal !== 'function')
+            return;
+        const orig = proto.showModal;
+        if (orig.__nsHmrModalTracked) {
+            modalTrackingInstalled = true;
+            return;
+        }
+        const wrapped = function (...args) {
+            const result = orig.apply(this, args);
+            try {
+                if (typeof args[0] === 'string' && result) {
+                    // Mirror core's getModalOptions arg shapes: (moduleName, options)
+                    // or the deprecated positional form.
+                    const options = args.length === 2 && args[1] && typeof args[1] === 'object' ? args[1] : { context: args[1], closeCallback: args[2], fullscreen: args[3], animated: args[4], stretched: args[5] };
+                    const moduleName = String(args[0])
+                        .replace(/^\.\//, '')
+                        .replace(/\.(xml|ts|js)$/i, '');
+                    openModalRecords.push({ moduleName, options, parent: this, modal: result });
+                    if (VERBOSE)
+                        console.log('[hmr][modal] tracked open modal', moduleName);
+                }
+            }
+            catch { }
+            return result;
+        };
+        wrapped.__nsHmrModalTracked = true;
+        proto.showModal = wrapped;
+        modalTrackingInstalled = true;
+    }
+    catch (e) {
+        if (VERBOSE)
+            console.warn('[hmr][modal] tracking install failed', e);
+    }
+}
+/**
+ * Enumerate the modals that are currently presented AND were opened by module
+ * name, with everything needed to re-present them.
+ *
+ * Source of truth is core's live modal stack (`_getRootModalViews()`):
+ *   - `modal._moduleName` — set by the Builder on every createViewFromEntry
+ *     view (longstanding, used by livesync), so available on any core.
+ *   - `modal._modalOptions` — the original ShowModalOptions, stored by core's
+ *     `_showNativeModalView` (newer cores). For older cores the showModal
+ *     wrap's records (see ensureModalTracking) fill the gap.
+ *   - `modal._modalParent` — the presenting view.
+ * Stale wrap records are pruned against the live stack while we're here.
+ */
+function getOpenStringModuleModals() {
+    const out = [];
+    try {
+        const App = getCore('Application');
+        const root = App?.getRootView?.() || App?._rootView;
+        const stack = root?._getRootModalViews?.() || [];
+        // Prune wrap records whose modal is gone (keeps the fallback list small).
+        for (let i = openModalRecords.length - 1; i >= 0; i--) {
+            if (!stack.includes(openModalRecords[i].modal)) {
+                openModalRecords.splice(i, 1);
+            }
+        }
+        for (const modal of stack) {
+            const record = openModalRecords.find((r) => r.modal === modal);
+            const rawModuleName = typeof modal?._moduleName === 'string' && modal._moduleName ? modal._moduleName : record?.moduleName;
+            const parent = modal?._modalParent || record?.parent;
+            const options = modal?._modalOptions || record?.options;
+            if (!rawModuleName || !parent)
+                continue;
+            const moduleName = String(rawModuleName)
+                .replace(/^\.\//, '')
+                .replace(/\.(xml|ts|js)$/i, '');
+            out.push({ moduleName, options, parent, modal });
+        }
+    }
+    catch (e) {
+        if (VERBOSE)
+            console.warn('[hmr][modal] open-modal enumeration failed', e);
+    }
+    return out;
+}
+/**
+ * Close and re-present an open modal so it rebuilds from the freshly
+ * re-registered XML/code-behind. Core clears the modal stack synchronously on
+ * close but the NATIVE dismissal completes asynchronously; iOS refuses a
+ * present while a dismissal is in flight. Newer cores fire `closedModally` on
+ * the modal at exactly that completion point — preferred signal. Older cores
+ * fall back to polling `isLoaded` (flipped by `_tearDownUI` in the same
+ * completion callback).
+ */
+async function reshowOpenModal(record) {
+    const { parent, modal, moduleName, options } = record;
+    await new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+            if (!settled) {
+                settled = true;
+                resolve();
+            }
+        };
+        let eventArmed = false;
+        try {
+            if (typeof modal.once === 'function') {
+                modal.once('closedModally', finish);
+                eventArmed = true;
+            }
+        }
+        catch { }
+        // Poll fallback (also the safety net if the event never fires —
+        // e.g. an interactive-dismiss cancellation).
+        const deadline = Date.now() + 2000;
+        const poll = () => {
+            if (settled)
+                return;
+            let stillLoaded = false;
+            try {
+                stillLoaded = !!modal.isLoaded;
+            }
+            catch { }
+            if ((!eventArmed && !stillLoaded) || Date.now() > deadline) {
+                finish();
+                return;
+            }
+            setTimeout(poll, 50);
+        };
+        setTimeout(poll, 50);
+        try {
+            modal.closeModal();
+        }
+        catch (e) {
+            if (VERBOSE)
+                console.warn('[hmr][modal] close failed for', moduleName, e);
+            finish();
+        }
+    });
+    // One settle beat so the platform finishes releasing the presentation
+    // before the new present begins.
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    try {
+        parent.showModal(moduleName, { ...(options || {}), animated: false });
+        if (VERBOSE)
+            console.log('[hmr][modal] re-presented', moduleName);
+    }
+    catch (e) {
+        console.warn('[hmr][modal] re-present failed for', moduleName, e);
+    }
+}
 async function processQueue() {
     if (!globalThis.__NS_HMR_BOOT_COMPLETE__) {
         if (VERBOSE)
@@ -857,6 +1039,27 @@ async function processQueue() {
                     if (VERBOSE)
                         console.log('[hmr][queue] re-import', { id, spec, url });
                     const mod = await import(/* @vite-ignore */ url);
+                    // TS/XML flavor: refresh the bundler module registry with the fresh
+                    // exports so Builder.createViewFromEntry / loadModule('<page>')
+                    // resolves the NEW code-behind (tap handlers, page events) instead
+                    // of the stale module captured in the boot bundle. Without this,
+                    // XML re-renders pick up new markup but keep old behavior.
+                    if (TARGET_FLAVOR === 'typescript' && mod && /\.(ts|js)$/i.test(id)) {
+                        try {
+                            const g = globalThis;
+                            const moduleName = toAppModuleName(id);
+                            if (moduleName && typeof g.registerModule === 'function') {
+                                g.registerModule(moduleName, () => mod);
+                                g.registerModule('./' + moduleName, () => mod);
+                                if (VERBOSE)
+                                    console.log('[hmr][queue] re-registered code-behind', moduleName);
+                            }
+                        }
+                        catch (e) {
+                            if (VERBOSE)
+                                console.warn('[hmr][queue] code-behind re-register failed for', id, e);
+                        }
+                    }
                 }
                 catch (e) {
                     if (VERBOSE)
@@ -1163,10 +1366,9 @@ async function processQueue() {
                                             const rawContent = await resp.text();
                                             // Register under all nickname variants the module registry uses.
                                             // The bundler context registers XML as e.g., './main-page.xml' and 'main-page.xml'
-                                            const appVirtual = APP_VIRTUAL_WITH_SLASH.replace(/^\//, '');
-                                            let relPath = spec.startsWith('/') ? spec.slice(1) : spec;
-                                            if (relPath.startsWith(appVirtual))
-                                                relPath = relPath.slice(appVirtual.length);
+                                            const relPath = toAppRelativePath(id);
+                                            if (!relPath)
+                                                continue;
                                             const nicknames = ['./' + relPath, relPath];
                                             // Also add without extension for CSS
                                             const extIdx = relPath.lastIndexOf('.');
@@ -1192,21 +1394,24 @@ async function processQueue() {
                                 }
                             }
                         }
+                        // Modal-aware refresh: pages currently PRESENTED AS MODALS must be
+                        // closed + re-presented in place — navigating the top frame to a
+                        // modal's page would push it as a frame page, and resetRootView
+                        // would dismiss the modal entirely. State comes from core's live
+                        // modal stack (_moduleName/_modalOptions/_modalParent); the
+                        // showModal wrap only backfills options on older cores.
+                        ensureModalTracking();
+                        const openModals = getOpenStringModuleModals();
+                        const changedModuleNames = new Set(drained.map(toAppModuleName).filter(Boolean));
+                        const modalsToReshow = openModals.filter((record) => changedModuleNames.has(record.moduleName));
+                        const reshowModuleNames = new Set(modalsToReshow.map((record) => record.moduleName));
                         // Determine if we can navigate in-place to a changed page
                         // instead of resetting all the way back to app-root.
                         // This keeps the user on the page they're editing for faster iteration.
                         const changedXmlPages = drained
                             .filter((id) => /\.xml$/i.test(id))
-                            .map((id) => {
-                            const spec = normalizeSpec(id);
-                            const appVirtual = APP_VIRTUAL_WITH_SLASH.replace(/^\//, '');
-                            let relPath = spec.startsWith('/') ? spec.slice(1) : spec;
-                            if (relPath.startsWith(appVirtual))
-                                relPath = relPath.slice(appVirtual.length);
-                            // Strip .xml extension to get the moduleName (e.g., 'pages/status-bar')
-                            return relPath.replace(/\.xml$/i, '');
-                        })
-                            .filter((m) => m && m !== 'app-root');
+                            .map((id) => toAppModuleName(id))
+                            .filter((m) => m && m !== 'app-root' && !reshowModuleNames.has(m));
                         // Resolve the topmost Frame from the bundled realm.
                         // Frame.topmost() relies on an internal frameStack array, so we must
                         // call it on the bundled-realm class. Multiple strategies to find it:
@@ -1242,7 +1447,7 @@ async function processQueue() {
                             catch { }
                         }
                         if (VERBOSE)
-                            console.log('[hmr][queue] TS: changedXmlPages=', changedXmlPages, 'topFrame=', !!topFrame);
+                            console.log('[hmr][queue] TS: changedXmlPages=', changedXmlPages, 'topFrame=', !!topFrame, 'modalsToReshow=', modalsToReshow.length);
                         if (changedXmlPages.length > 0 && topFrame) {
                             // Navigate the current frame to the changed page directly.
                             // Use the last changed XML page (most specific).
@@ -1257,11 +1462,21 @@ async function processQueue() {
                                 App.resetRootView({ moduleName: 'app-root' });
                             }
                         }
-                        else {
+                        else if (modalsToReshow.length === 0) {
+                            // No frame page to refresh and no open modal owns the change —
+                            // fall back to a full root reset. (Skipped when an open modal is
+                            // being re-presented below: resetRootView would dismiss it.)
                             if (VERBOSE)
                                 console.log('[hmr][queue] TS flavor: resetRootView(app-root) after changes');
                             App.resetRootView({ moduleName: 'app-root' });
                         }
+                        // Re-present any open modals whose XML/code-behind changed. The
+                        // modules were already re-registered above (raw XML assets + fresh
+                        // code-behind exports), so the re-presented modal rebuilds from
+                        // the new content while the page beneath it stays put.
+                        for (const record of modalsToReshow) {
+                            await reshowOpenModal(record);
+                        }
                     }
                     catch (e) {
                         console.warn('[hmr][queue] TS flavor: resetRootView(app-root) failed', e);
@@ -2241,6 +2456,20 @@ export function initHmrClient(opts) {
     }
     g.__NS_HMR_CLIENT_ACTIVE__ = true;
     ensureCoreAliasesOnGlobalThis();
+    // XML flavor: record string-module modals from the moment the client is up
+    // so an already-open modal can be re-presented when its files change.
+    // Installed at init (not first-update time) because the wrap can only
+    // observe showModal calls made AFTER it lands. Retried briefly because
+    // getCore('View') may not resolve until the vendor realm finishes booting.
+    if (TARGET_FLAVOR === 'typescript') {
+        const tryInstallModalTracking = (attempts) => {
+            ensureModalTracking();
+            if (!modalTrackingInstalled && attempts > 0) {
+                setTimeout(() => tryInstallModalTracking(attempts - 1), 250);
+            }
+        };
+        tryInstallModalTracking(40);
+    }
     // Defer WebSocket connection until boot completes to avoid native V8 crashes
     // caused by concurrent WebSocket message handling + HTTP fetch during early startup.
     // The WebSocket is only needed for HMR updates, not the initial boot sequence.