ember-vite-hmr 2.2.4 → 2.3.0

package/dist/lib/babel-plugin.js

@@ -221,17 +221,73 @@ export default function hotReplaceAst(babel) {
             if (import.meta.hot) {
               import.meta.hot.data._proxy = this;
             }
+            // Bound methods are cached per-delegate (not per-proxy) so identity
+            // stays stable across repeated reads of the same delegate (e.g.
+            // {{on "click" this.svc.handler}} comparing args by reference), while
+            // naturally invalidating once a delegate is swapped out on HMR accept.
+            const boundMethods = new WeakMap();
             return new Proxy(this, {
-              get(target, prop) {
+              get(target, prop, receiver) {
                 if (prop === '_delegate') {
                   return target._delegate;
                 }
-                return target._delegate[prop];
+                // A subclass of this service (see the Reflect.get fallback
+                // below) may override a method the base delegate class also
+                // defines. Since 'prop in delegate' walks the delegate's
+                // *entire* prototype chain, it would match the base
+                // implementation before the subclass's own override ever
+                // gets a chance -- so look for an own property between
+                // target's dynamic prototype and this proxy's own prototype
+                // first, and prefer it over the delegate.
+                let proto = Object.getPrototypeOf(target);
+                while (proto && proto !== ${proxyClassName}.prototype) {
+                  if (Object.prototype.hasOwnProperty.call(proto, prop)) {
+                    return Reflect.get(target, prop, receiver);
+                  }
+                  proto = Object.getPrototypeOf(proto);
+                }
+                const delegate = target._delegate;
+                // Methods invoked via normal member-call syntax (service.method())
+                // bind 'this' to whatever object the property access happened on
+                // -- the proxy, here -- not to the delegate. That breaks native
+                // private fields, whose storage lives only on the concrete
+                // delegate instance, so delegate-owned methods are explicitly
+                // bound to the delegate.
+                if (prop in delegate) {
+                  const value = delegate[prop];
+                  if (typeof value === 'function') {
+                    let cache = boundMethods.get(delegate);
+                    if (!cache) {
+                      cache = new Map();
+                      boundMethods.set(delegate, cache);
+                    }
+                    let bound = cache.get(prop);
+                    if (!bound) {
+                      bound = value.bind(delegate);
+                      cache.set(prop, bound);
+                    }
+                    return bound;
+                  }
+                  return value;
+                }
+                // Not on the delegate: fall through to the proxy's own real
+                // prototype chain, which covers methods declared on a subclass
+                // of this service (the subclass never went through this babel
+                // transform itself, since it doesn't extend Service directly).
+                return Reflect.get(target, prop, receiver);
               },
               set(target, prop, value) {
                 target._delegate[prop] = value;
                 return true;
               },
+              defineProperty(target, prop, descriptor) {
+                // A subclass's own class fields are installed via
+                // [[DefineOwnProperty]] against whatever 'this' super() returned
+                // (this proxy), bypassing the 'set' trap entirely. Route them to
+                // the delegate too, so subclass state lives alongside the rest
+                // of the service's state instead of stranded on the proxy target.
+                return Reflect.defineProperty(target._delegate, prop, descriptor);
+              },
             });
           `)();
                 const willDestroyBody = babelTemplate.statements(`
@@ -309,8 +365,19 @@ export default function hotReplaceAst(babel) {
                     continue;
                   }
 
-                  // Skip Function properties - they should not be synced
-                  if (typeof previousValue === 'function') {
+                  // Skip function properties that the new implementation also
+                  // declares (a fresh redefinition should win over the old
+                  // one). But a function-valued property the new
+                  // implementation *doesn't* declare at all isn't a stale
+                  // redefinition -- it's state a subclass installed on the
+                  // delegate directly (subclasses of this service never go
+                  // through this transform themselves, since their
+                  // superclass isn't literally named Service; their own
+                  // class fields land on the delegate via the proxy's
+                  // defineProperty trap instead). Dropping it here would
+                  // silently break e.g. an arrow-function class field on a
+                  // subclass across a base-class HMR swap.
+                  if (typeof previousValue === 'function' && hasOwnDefault) {
                     continue;
                   }
 

package/dist/lib/hmr.js

@@ -141,6 +141,17 @@ shadowManager.create = function (owner, definition, vmArgs) {
     capturedArgsStack.pop();
   }
 };
+// Glimmer's debug render tree normally adds one 'component' node per
+// invoked component instance (see VM_GET_COMPONENT_SELF_OP). Returning no
+// nodes here suppresses that node for HotComponent itself, so only the
+// real, curried target component (invoked in HotComponent's own template)
+// shows up in ember-inspector's component tree - this is the same hook
+// Ember core uses internally to keep its own {{outlet}}/{{mount}} wrapper
+// machinery out of (or relabeled in) that tree (see OutletComponentManager
+// and MountManager in ember-source).
+shadowManager.getDebugCustomRenderTree = function () {
+  return [];
+};
 setInternalComponentManager(shadowManager, HotComponent);
 `;
 const cachedYields = {};
@@ -188,7 +199,8 @@ export function hmr(enableViteHmrForModes = ['development']) {
     return {
         name: 'hmr-plugin',
         enforce: 'post',
-        config(_config, env) {
+        config(config, env) {
+            var _a;
             // The per-component hot wrapper (see getHotComponent) imports the first
             // four of these, but it is generated/served on demand, so it is never
             // part of the static module graph Vite's dependency scanner crawls on
@@ -207,6 +219,18 @@ export function hmr(enableViteHmrForModes = ['development']) {
             if (!enableViteHmrForModes.includes(env.mode)) {
                 return;
             }
+            // With `optimizeDeps.noDiscovery: true`, Vite never scans the app's own
+            // source, so nothing else pulls these same glimmer subpaths into the
+            // optimizer. Forcing them into `include` then creates a second,
+            // separately pre-bundled copy of the glimmer VM alongside the
+            // unoptimized one the rest of the (unscanned) app actually uses,
+            // leading to "The global context for Glimmer VM was not set" (#554).
+            // There's nothing useful this hook can pre-declare in that mode, so
+            // skip it entirely rather than fight the user's own dep-optimization
+            // config.
+            if ((_a = config.optimizeDeps) === null || _a === void 0 ? void 0 : _a.noDiscovery) {
+                return;
+            }
             return {
                 optimizeDeps: {
                     include: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-vite-hmr",
-  "version": "2.2.4",
+  "version": "2.3.0",
   "private": false,
   "description": "provides hmr support for ember apps",
   "keywords": [
@@ -14,7 +14,8 @@
   "author": "Patrick Pircher",
   "exports": {
     ".": {
-      "default": "./dist/lib/hmr.js"
+      "node": "./dist/lib/hmr.js",
+      "default": null
     },
     "./*": {
       "types": "./declarations/*.d.ts",
@@ -22,7 +23,6 @@
     },
     "./addon-main.js": "./addon-main.cjs"
   },
-  "main": "dist/lib/hmr.js",
   "typesVersions": {
     "*": {
       "*": [
@@ -38,7 +38,7 @@
     "@babel/core": "^7.29.0",
     "@babel/plugin-transform-typescript": "^7.28.6",
     "@babel/traverse": "^7.29.0",
-    "@babel/types": "^8.0.4",
+    "@babel/types": "^7.28.5",
     "@embroider/addon-shim": "^1.10.3",
     "@glimmer/syntax": "^0.95.0",
     "@types/supports-color": "^10.0.0",
@@ -52,7 +52,7 @@
     "@babel/plugin-proposal-class-properties": "^7.16.7",
     "@babel/plugin-proposal-decorators": "^7.28.0",
     "@babel/plugin-transform-class-static-block": "^7.28.6",
-    "@babel/runtime": "^8.0.0",
+    "@babel/runtime": "^7.28.4",
     "@embroider/addon-dev": "^8.3.0",
     "@embroider/compat": "^4.1.20",
     "@embroider/core": "^4.6.2",