ember-vite-hmr 2.3.0 → 2.7.0

package/README.md

@@ -28,11 +28,42 @@ export default class MyComponent extends Component {
 ```
 
 This hook is called after automatic state synchronization but before the old instance is destroyed, allowing you to:
+
 - Perform custom state migrations
 - Clean up resources
 - Log HMR events
 - Handle complex state transitions
 
+### Private class fields
+
+Services are hot-reloaded through a generated proxy that forwards property
+access to the current delegate instance. Native `#private` class fields and
+methods only work when `this` is the exact instance that declared them, so
+this plugin rewrites every native `#private` member declared in your app's
+own source (on the service itself and any ancestor class it extends, as
+long as that ancestor is also part of your app) to a plain, uniquely-named
+property. An undecorated field is also made non-enumerable (via
+`Object.defineProperty`), so it's hidden from `for...in`, `Object.keys`,
+`JSON.stringify`, and spread — the same as a native `#private` member. A
+private method already was non-enumerable, since class method syntax is
+non-enumerable by default regardless of this rewrite. A
+`@tracked #field` is the one exception: the decorator turns it into an
+accessor on the prototype rather than an instance data property, so it's
+left exactly as the plain rewrite produces it, enumerable or not according
+to whatever `@tracked` itself does with an ordinary public field. In every
+case this only emulates privacy: the member is reachable and writable from
+outside via its generated name (e.g. through `Object.getOwnPropertyNames`,
+`Reflect.ownKeys`, or devtools) — unlike a real native `#private` field. It's
+obscured, not encapsulated, so don't rely on it as a serialization or
+security boundary.
+
+The one case this can't cover: a base class living in `node_modules` (never
+processed by this plugin) that declares its own native `#private` fields.
+A service extending such a class would still need `this` to be the real
+instance to read those fields, so proxying that service could break. Ember's
+own `Service`/`EmberObject`/`CoreObject` chain declares no native `#private`
+fields, so ordinary Ember apps are unaffected.
+
 ## Installation
 
 ```

package/dist/instance-initializers/setup-hmr-manager.js

@@ -3,6 +3,13 @@ import Service from '@ember/service';
 import Component from '@glimmer/component';
 import { getInternalComponentManager } from '@glimmer/manager';
 
+// Accessor for the HMR runtime helpers exposed on the global by
+// virtual:ember-vite-hmr-runtime. Only set in dev/serve mode (guarded by
+// `if (!import.meta.hot)` at the call site).
+
+function hmrRuntime() {
+  return globalThis.__ember_vite_hmr;
+}
 function findPropertyDescriptor(component, key) {
   let proto = component;
   while (proto) {
@@ -11,6 +18,33 @@ function findPropertyDescriptor(component, key) {
     proto = Object.getPrototypeOf(proto);
   }
 }
+
+// The private property key `ember-resources`' `wrapForPlainUsage()` uses on
+// the plain object it wraps in a Proxy for `resource()` (which reactiveweb's
+// `trackedTask` uses internally) - see
+// https://github.com/NullVoxPopuli/ember-resources/blob/main/ember-resources/src/plain/index.ts.
+// Carrying such a proxy's *reference* over onto a new HMR-swapped instance
+// (instead of leaving the new instance's own, correctly-parented resource in
+// place) is unsafe: the proxy's underlying helper cache is lazily created on
+// first property read and permanently bound, at that point, to whichever
+// component instance was passed as `context` when `resource()` was called -
+// for a carried-over proxy that's always the *old*, already-destroyed
+// instance, so the first read after the swap throws "Attempted to associate
+// a destroyable child with an object that is already destroying or
+// destroyed" - see issue #563.
+//
+// `in` is used (rather than reading a property, or `Object.keys`/
+// `Object.prototype.toString.call`) because it's the one reflective
+// operation `wrapForPlainUsage`'s Proxy doesn't trap (no `has` handler), so
+// it forwards to a plain `[[HasProperty]]` on the underlying target without
+// ever invoking the lazy getter - it can't accidentally trigger the same
+// crash it's checking for. If `ember-resources` ever renames this key, this
+// check simply stops matching and behavior falls back to today's (already
+// broken, pre-existing) state - it does not introduce a new failure mode.
+const RESOURCE_INTERMEDIATE_VALUE_KEY = '__Intermediate_Value__';
+function isUnsafeToCarryOver(value) {
+  return (typeof value === 'object' || typeof value === 'function') && value !== null && RESOURCE_INTERMEDIATE_VALUE_KEY in value;
+}
 function getState(component, skip) {
   const state = {};
   if (!component) {
@@ -30,35 +64,41 @@ function getState(component, skip) {
     if (typeof value === 'function') {
       continue;
     }
+
+    // Skip resource()-backed proxies - see isUnsafeToCarryOver above.
+    if (isUnsafeToCarryOver(value)) {
+      continue;
+    }
     if (entry) {
-      if (entry.writable && !Object.prototype.toString.call(entry.value).includes('Function')) {
-        state[key] = component[key];
+      // Note: don't probe `entry.value` any further here (e.g. via
+      // `Object.prototype.toString.call`) to decide whether it's a plain
+      // function - the `typeof value === 'function'` check above already
+      // covers that, and a stricter check on `entry.value` (which may be a
+      // resource proxy, e.g. reactiveweb's `trackedTask`) can trigger that
+      // proxy's `get` trap on first touch, lazily invoking a helper against
+      // this component instance - see issue #557.
+      if (entry.writable) {
+        state[key] = value;
       }
       if (entry.set) {
-        state[key] = component[key];
+        state[key] = value;
       }
     }
   }
   return state;
 }
-function syncState(instance) {
-  const args = instance.args;
-  if (args.__hot__) {
-    const oldInstance = args.__hot__.oldInstance;
-    const state = instance.__get_hot_state__?.() || args.__hot__.getState?.();
-    for (const k in state) {
-      if (instance[k] instanceof Service) {
-        continue;
-      }
-      instance[k] = state[k];
-    }
 
-    // Call _hmrAccepted hook if defined
-    if (typeof instance._hmrAccepted === 'function') {
-      instance._hmrAccepted(oldInstance);
+// Apply a stashed old-instance state to a freshly created new instance.
+// Also calls the _hmrAccepted lifecycle hook if defined on the new instance.
+function applySyncState(instance, state, oldInstance) {
+  for (const k in state) {
+    if (instance[k] instanceof Service) {
+      continue;
     }
-    args.__hot__.getState = () => getState(instance, ['args']);
-    args.__hot__.oldInstance = instance;
+    instance[k] = state[k];
+  }
+  if (typeof instance._hmrAccepted === 'function') {
+    instance._hmrAccepted(oldInstance);
   }
 }
 function initialize() {
@@ -69,9 +109,53 @@ function initialize() {
   const proto = Object.getPrototypeOf(ComponentManager);
   const create = proto.create;
   proto.create = function (...args) {
-    const instance = create.call(this, ...args);
-    setTimeout(() => syncState(instance.component));
-    return instance;
+    const bucket = create.call(this, ...args);
+    const component = bucket.component;
+
+    // Enqueue this instance in the runtime's per-class FIFO queue. The runtime
+    // only enqueues when isHmrClass(klass) is true (registered HMR class), and
+    // clears the queue at update() time so user-flow stale entries are never
+    // present when willDestroy fires during an HMR swap.
+    const klass = component.constructor;
+    const rt = hmrRuntime();
+    if (rt?.isHmrClass(klass)) {
+      rt.enqueueInstance(klass, component);
+    }
+    return bucket;
+  };
+
+  // Patch willDestroy on the Component prototype to detect HMR swaps and
+  // transfer state from the old instance to the freshly-created new one.
+  //
+  // Why willDestroy instead of registerDestructor: Glimmer creates the NEW
+  // component instance BEFORE calling willDestroy on the OLD one (willDestroy
+  // is scheduled in Ember's "actions" runloop queue, which runs after
+  // rendering). This ordering is exactly what we need: by willDestroy time,
+  // the new instance is already live in liveInstances.
+  const origWillDestroy = Component.prototype.willDestroy;
+  Component.prototype.willDestroy = function () {
+    const rt = hmrRuntime();
+    if (rt) {
+      const klass = this.constructor;
+      const newClass = rt.current(klass);
+      if (newClass !== klass) {
+        // The class was swapped via HMR — dequeue the next new instance for
+        // the replacement class (FIFO matches DOM/creation order) and
+        // schedule a state transfer onto it.
+        const newInstance = rt.dequeueInstance(newClass);
+        if (newInstance) {
+          const state = getState(this, ['args']);
+          const oldInstance = this;
+          setTimeout(() => applySyncState(newInstance, state, oldInstance));
+        }
+      } else if (rt.isHmrClass(klass)) {
+        // Normal destroy (navigation, timer, conditional) — remove this
+        // instance from the live queue so it doesn't accumulate as a stale
+        // entry that update() would otherwise have to clear at the next save.
+        rt.removeInstance(klass, this);
+      }
+    }
+    return origWillDestroy?.call(this);
   };
   const setupController = Route.prototype.setupController;
   const StateCache = {};

package/dist/instance-initializers/setup-hmr-manager.js.map

@@ -1 +1 @@
-{"version":3,"file":"setup-hmr-manager.js","sources":["../../src/instance-initializers/setup-hmr-manager.ts"],"sourcesContent":["import Route from '@ember/routing/route';\nimport Service from '@ember/service';\nimport Component from '@glimmer/component';\nimport { getInternalComponentManager } from '@glimmer/manager';\n\ninterface HotComponent extends Component<{ __hot__?: unknown }> {\n  __get_hot_state__?: () => Record<string, unknown>;\n  _hmrAccepted?: (oldInstance?: HotComponent) => void;\n  [key: string]: unknown;\n}\n\ntype Mutable<T> = {\n  -readonly [P in keyof T]: unknown;\n};\n\nfunction findPropertyDescriptor(\n  component: HotComponent | Record<string, unknown>,\n  key: string,\n) {\n  let proto = component;\n  while (proto) {\n    const desc = Object.getOwnPropertyDescriptor(proto, key);\n    if (desc) return desc;\n    proto = Object.getPrototypeOf(proto);\n  }\n}\n\nfunction getState(component: HotComponent, skip: string[]) {\n  const state: Record<string, unknown> = {};\n  if (!component) {\n    return state;\n  }\n  for (const key in component) {\n    if (skip.includes(key)) continue;\n    const entry = findPropertyDescriptor(component, key);\n    const value = component[key as keyof Component];\n    \n    // Skip Service instances - they should not be synced\n    if (value instanceof Service) {\n      continue;\n    }\n    \n    // Skip Function properties - they should not be synced\n    if (typeof value === 'function') {\n      continue;\n    }\n    \n    if (entry) {\n      if (\n        entry.writable &&\n        !Object.prototype.toString.call(entry.value).includes('Function')\n      ) {\n        state[key] = component[key as keyof Component];\n      }\n      if (entry.set) {\n        state[key] = component[key as keyof Component];\n      }\n    }\n  }\n  return state;\n}\n\nfunction syncState(instance: Mutable<HotComponent>) {\n  const args = instance.args as { __hot__?: { getState?: () => Record<string, unknown>; oldInstance?: HotComponent } };\n  if (args.__hot__) {\n    const oldInstance = args.__hot__.oldInstance;\n    const state =\n      (instance.__get_hot_state__ as (() => Record<string, unknown>) | undefined)?.() || args.__hot__.getState?.();\n    for (const k in state) {\n      if (instance[k as keyof HotComponent] instanceof Service) {\n        continue;\n      }\n      instance[k as keyof HotComponent] = state[k];\n    }\n    \n    // Call _hmrAccepted hook if defined\n    if (typeof instance._hmrAccepted === 'function') {\n      instance._hmrAccepted(oldInstance);\n    }\n    \n    args.__hot__.getState = () => getState(instance as HotComponent, ['args']);\n    args.__hot__.oldInstance = instance as HotComponent;\n  }\n}\n\nexport function initialize() {\n  // HMR-only: in a production build `import.meta.hot` is undefined, so this\n  // (and the manager/route monkey-patches below) is dead-code-eliminated.\n  if (!import.meta.hot) return;\n\n  const ComponentManager = getInternalComponentManager(Component);\n  const proto = Object.getPrototypeOf(ComponentManager);\n  const create = proto.create;\n  proto.create = function (...args: unknown[]) {\n    const instance = create.call(this, ...args);\n    setTimeout(() => syncState(instance.component));\n    return instance;\n  };\n\n  const setupController = Route.prototype.setupController;\n\n  const StateCache: Record<string, unknown> = {};\n\n  Route.prototype.setupController = function (...args: Parameters<typeof setupController>) {\n    const controller = args[0] as unknown as Record<string, unknown>;\n    const r = setupController.call(this, ...args);\n    const fullRouteName = this.fullRouteName;\n    const state = StateCache[fullRouteName] as { router?: Record<string, unknown>; controller?: Record<string, unknown> } || {};\n    const skip = ['_qpDelegate', 'target', 'queryParams'];\n    const routerState = getState(state.router as HotComponent, skip);\n    for (const k in routerState) {\n      (this as unknown as Record<string, unknown>)[k] = routerState[k];\n    }\n    // Only re-apply controller state onto a *new* instance (an HMR swap). On\n    // ordinary navigation it is the same singleton, and re-applying a\n    // non-`@tracked` query param onto itself trips Ember's mandatory setter.\n    if (state.controller && state.controller !== controller) {\n      const controllerState = getState(state.controller as HotComponent, skip);\n      for (const k in controllerState) {\n        (controller as Record<string, unknown>)[k] = controllerState[k];\n      }\n    }\n    StateCache[fullRouteName] = {\n      route: this,\n      controller,\n    };\n    return r;\n  };\n}\n\nexport default {\n  initialize,\n};\n"],"names":["findPropertyDescriptor","component","key","proto","desc","Object","getOwnPropertyDescriptor","getPrototypeOf","getState","skip","state","includes","entry","value","Service","writable","prototype","toString","call","set","syncState","instance","args","__hot__","oldInstance","__get_hot_state__","k","_hmrAccepted","initialize","import","meta","hot","ComponentManager","getInternalComponentManager","Component","create","setTimeout","setupController","Route","StateCache","controller","r","fullRouteName","routerState","router","controllerState","route"],"mappings":"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"}
+{"version":3,"file":"setup-hmr-manager.js","sources":["../../src/instance-initializers/setup-hmr-manager.ts"],"sourcesContent":["import Route from '@ember/routing/route';\nimport Service from '@ember/service';\nimport Component from '@glimmer/component';\nimport { getInternalComponentManager } from '@glimmer/manager';\n\ninterface HotComponent extends Component {\n  __get_hot_state__?: () => Record<string, unknown>;\n  _hmrAccepted?: (oldInstance?: HotComponent) => void;\n  [key: string]: unknown;\n}\n\ntype Mutable<T> = {\n  -readonly [P in keyof T]: unknown;\n};\n\n// Accessor for the HMR runtime helpers exposed on the global by\n// virtual:ember-vite-hmr-runtime. Only set in dev/serve mode (guarded by\n// `if (!import.meta.hot)` at the call site).\ninterface HmrRuntime {\n  current: (value: unknown) => unknown;\n  isHmrClass: (value: unknown) => boolean;\n  enqueueInstance: (klass: unknown, instance: HotComponent) => void;\n  dequeueInstance: (klass: unknown) => HotComponent | null;\n  removeInstance: (klass: unknown, instance: HotComponent) => void;\n}\n\nfunction hmrRuntime(): HmrRuntime | undefined {\n  return (globalThis as unknown as { __ember_vite_hmr?: HmrRuntime }).__ember_vite_hmr;\n}\n\nfunction findPropertyDescriptor(\n  component: HotComponent | Record<string, unknown>,\n  key: string,\n) {\n  let proto = component;\n  while (proto) {\n    const desc = Object.getOwnPropertyDescriptor(proto, key);\n    if (desc) return desc;\n    proto = Object.getPrototypeOf(proto);\n  }\n}\n\n// The private property key `ember-resources`' `wrapForPlainUsage()` uses on\n// the plain object it wraps in a Proxy for `resource()` (which reactiveweb's\n// `trackedTask` uses internally) - see\n// https://github.com/NullVoxPopuli/ember-resources/blob/main/ember-resources/src/plain/index.ts.\n// Carrying such a proxy's *reference* over onto a new HMR-swapped instance\n// (instead of leaving the new instance's own, correctly-parented resource in\n// place) is unsafe: the proxy's underlying helper cache is lazily created on\n// first property read and permanently bound, at that point, to whichever\n// component instance was passed as `context` when `resource()` was called -\n// for a carried-over proxy that's always the *old*, already-destroyed\n// instance, so the first read after the swap throws \"Attempted to associate\n// a destroyable child with an object that is already destroying or\n// destroyed\" - see issue #563.\n//\n// `in` is used (rather than reading a property, or `Object.keys`/\n// `Object.prototype.toString.call`) because it's the one reflective\n// operation `wrapForPlainUsage`'s Proxy doesn't trap (no `has` handler), so\n// it forwards to a plain `[[HasProperty]]` on the underlying target without\n// ever invoking the lazy getter - it can't accidentally trigger the same\n// crash it's checking for. If `ember-resources` ever renames this key, this\n// check simply stops matching and behavior falls back to today's (already\n// broken, pre-existing) state - it does not introduce a new failure mode.\nconst RESOURCE_INTERMEDIATE_VALUE_KEY = '__Intermediate_Value__';\n\nfunction isUnsafeToCarryOver(value: unknown): boolean {\n  return (\n    (typeof value === 'object' || typeof value === 'function') &&\n    value !== null &&\n    RESOURCE_INTERMEDIATE_VALUE_KEY in value\n  );\n}\n\nfunction getState(component: HotComponent, skip: string[]) {\n  const state: Record<string, unknown> = {};\n  if (!component) {\n    return state;\n  }\n  for (const key in component) {\n    if (skip.includes(key)) continue;\n    const entry = findPropertyDescriptor(component, key);\n    const value = component[key as keyof Component];\n    \n    // Skip Service instances - they should not be synced\n    if (value instanceof Service) {\n      continue;\n    }\n    \n    // Skip Function properties - they should not be synced\n    if (typeof value === 'function') {\n      continue;\n    }\n\n    // Skip resource()-backed proxies - see isUnsafeToCarryOver above.\n    if (isUnsafeToCarryOver(value)) {\n      continue;\n    }\n\n    if (entry) {\n      // Note: don't probe `entry.value` any further here (e.g. via\n      // `Object.prototype.toString.call`) to decide whether it's a plain\n      // function - the `typeof value === 'function'` check above already\n      // covers that, and a stricter check on `entry.value` (which may be a\n      // resource proxy, e.g. reactiveweb's `trackedTask`) can trigger that\n      // proxy's `get` trap on first touch, lazily invoking a helper against\n      // this component instance - see issue #557.\n      if (entry.writable) {\n        state[key] = value;\n      }\n      if (entry.set) {\n        state[key] = value;\n      }\n    }\n  }\n  return state;\n}\n\n// Apply a stashed old-instance state to a freshly created new instance.\n// Also calls the _hmrAccepted lifecycle hook if defined on the new instance.\nfunction applySyncState(\n  instance: Mutable<HotComponent>,\n  state: Record<string, unknown>,\n  oldInstance: HotComponent | undefined,\n) {\n  for (const k in state) {\n    if (instance[k as keyof HotComponent] instanceof Service) {\n      continue;\n    }\n    instance[k as keyof HotComponent] = state[k];\n  }\n  if (typeof instance._hmrAccepted === 'function') {\n    instance._hmrAccepted(oldInstance);\n  }\n}\n\nexport function initialize() {\n  // HMR-only: in a production build `import.meta.hot` is undefined, so this\n  // (and the manager/route monkey-patches below) is dead-code-eliminated.\n  if (!import.meta.hot) return;\n\n  const ComponentManager = getInternalComponentManager(Component);\n  const proto = Object.getPrototypeOf(ComponentManager);\n  const create = proto.create;\n  proto.create = function (...args: unknown[]) {\n    const bucket = create.call(this, ...args);\n    const component = bucket.component as HotComponent;\n\n    // Enqueue this instance in the runtime's per-class FIFO queue. The runtime\n    // only enqueues when isHmrClass(klass) is true (registered HMR class), and\n    // clears the queue at update() time so user-flow stale entries are never\n    // present when willDestroy fires during an HMR swap.\n    const klass = component.constructor as object;\n    const rt = hmrRuntime();\n    if (rt?.isHmrClass(klass)) {\n      rt.enqueueInstance(klass, component);\n    }\n\n    return bucket;\n  };\n\n  // Patch willDestroy on the Component prototype to detect HMR swaps and\n  // transfer state from the old instance to the freshly-created new one.\n  //\n  // Why willDestroy instead of registerDestructor: Glimmer creates the NEW\n  // component instance BEFORE calling willDestroy on the OLD one (willDestroy\n  // is scheduled in Ember's \"actions\" runloop queue, which runs after\n  // rendering). This ordering is exactly what we need: by willDestroy time,\n  // the new instance is already live in liveInstances.\n  const origWillDestroy = Component.prototype.willDestroy;\n  Component.prototype.willDestroy = function (this: HotComponent) {\n    const rt = hmrRuntime();\n    if (rt) {\n      const klass = this.constructor as object;\n      const newClass = rt.current(klass);\n      if (newClass !== klass) {\n        // The class was swapped via HMR — dequeue the next new instance for\n        // the replacement class (FIFO matches DOM/creation order) and\n        // schedule a state transfer onto it.\n        const newInstance = rt.dequeueInstance(newClass);\n        if (newInstance) {\n          const state = getState(this, ['args']);\n          const oldInstance = this;\n          setTimeout(() => applySyncState(newInstance as Mutable<HotComponent>, state, oldInstance));\n        }\n      } else if (rt.isHmrClass(klass)) {\n        // Normal destroy (navigation, timer, conditional) — remove this\n        // instance from the live queue so it doesn't accumulate as a stale\n        // entry that update() would otherwise have to clear at the next save.\n        rt.removeInstance(klass, this);\n      }\n    }\n    return origWillDestroy?.call(this);\n  };\n\n  const setupController = Route.prototype.setupController;\n\n  const StateCache: Record<string, unknown> = {};\n\n  Route.prototype.setupController = function (...args: Parameters<typeof setupController>) {\n    const controller = args[0] as unknown as Record<string, unknown>;\n    const r = setupController.call(this, ...args);\n    const fullRouteName = this.fullRouteName;\n    const state = StateCache[fullRouteName] as { router?: Record<string, unknown>; controller?: Record<string, unknown> } || {};\n    const skip = ['_qpDelegate', 'target', 'queryParams'];\n    const routerState = getState(state.router as HotComponent, skip);\n    for (const k in routerState) {\n      (this as unknown as Record<string, unknown>)[k] = routerState[k];\n    }\n    // Only re-apply controller state onto a *new* instance (an HMR swap). On\n    // ordinary navigation it is the same singleton, and re-applying a\n    // non-`@tracked` query param onto itself trips Ember's mandatory setter.\n    if (state.controller && state.controller !== controller) {\n      const controllerState = getState(state.controller as HotComponent, skip);\n      for (const k in controllerState) {\n        (controller as Record<string, unknown>)[k] = controllerState[k];\n      }\n    }\n    StateCache[fullRouteName] = {\n      route: this,\n      controller,\n    };\n    return r;\n  };\n}\n\nexport default {\n  initialize,\n};\n"],"names":["hmrRuntime","globalThis","__ember_vite_hmr","findPropertyDescriptor","component","key","proto","desc","Object","getOwnPropertyDescriptor","getPrototypeOf","RESOURCE_INTERMEDIATE_VALUE_KEY","isUnsafeToCarryOver","value","getState","skip","state","includes","entry","Service","writable","set","applySyncState","instance","oldInstance","k","_hmrAccepted","initialize","import","meta","hot","ComponentManager","getInternalComponentManager","Component","create","args","bucket","call","klass","constructor","rt","isHmrClass","enqueueInstance","origWillDestroy","prototype","willDestroy","newClass","current","newInstance","dequeueInstance","setTimeout","removeInstance","setupController","Route","StateCache","controller","r","fullRouteName","routerState","router","controllerState","route"],"mappings":"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"}

package/dist/lib/babel-plugin/private-members.d.ts

@@ -0,0 +1,3 @@
+import type * as BabelTypesNamespace from '@babel/types';
+import type * as Babel from '@babel/core';
+export declare function renamePrivateClassMembers(babel: typeof Babel, classPath: Babel.NodePath<BabelTypesNamespace.ClassDeclaration | BabelTypesNamespace.ClassExpression>, programPath: Babel.NodePath<BabelTypesNamespace.Program>): void;

package/dist/lib/babel-plugin/private-members.js

@@ -0,0 +1,297 @@
+function hasPrivateMembers(classBody) {
+    return classBody.body.some((member) => member.type === 'ClassPrivateProperty' ||
+        member.type === 'ClassPrivateMethod');
+}
+// The generated HMR proxy (see service-proxy.ts's `ctorBody`) reads and
+// writes service state through a Proxy whose `get`/`set` traps forward to a
+// separately constructed delegate instance. Native `#private` fields can
+// only ever be accessed with `this` bound to the exact object that declared
+// them, and a method called as `proxy.method()` runs with `this` set to the
+// proxy, not the delegate -- so a `#private` field read from ANY function
+// reached through the proxy (a prototype method or a plain own-property
+// function assigned in the constructor) would throw "Cannot read private
+// member ... from an object whose class did not declare it" once called
+// through it. An earlier version of this proxy special-cased prototype
+// methods by `.bind()`-ing them to the delegate, but that's exactly
+// backwards for an own-property function value: `bind()` returns a fresh
+// function object, silently dropping any metadata identity-sensitive code
+// associates with the original one via a WeakMap (e.g.
+// `modifier()`/`helper()`, `setComponentManager` -- see #560/#561).
+//
+// Rewriting `#foo` to a plain, uniquely-named, non-computed property
+// sidesteps the whole problem instead: an ordinary property reads and
+// writes correctly through the proxy's existing traps no matter what `this`
+// is at the call site, so no per-property binding is needed at all. This
+// runs generically on *every* class the app's own source defines (see the
+// `Class` visitor in ../../babel-plugin.ts), not just service classes, so it
+// also covers `#private` fields on an ancestor class the service extends,
+// as long as that ancestor is part of the app's own source (and therefore
+// passes through this same babel pass). It does NOT help with a `#private`
+// field declared on an ancestor class that lives in `node_modules` -- that
+// file is never passed through this transform, so its fields stay fully
+// native, and a prototype method inherited from it would still crash if
+// called through the proxy. Ember's own `Service`/`EmberObject`/`CoreObject`
+// chain declares no native `#private` fields, so this doesn't affect normal
+// Ember apps; a third-party base class that does would need to stop using
+// native `#private` fields, or avoid extending it directly with an
+// HMR-proxied service.
+//
+// A Symbol-keyed property (an earlier version of this rewrite) would keep
+// the member non-enumerable, closer to real privacy, but Ember's `@tracked`
+// rejects it outright: `@glimmer/tracking`'s decorator entry point
+// distinguishes "I was invoked as a native decorator" from "I was invoked as
+// `tracked({...})`" by checking `typeof key === 'string'` (see
+// `isElementDescriptor` in `@ember/-internals`), so a `@tracked #count = 0`
+// field renamed to a Symbol key silently falls through to the wrong branch
+// and never tracks at all (verified empirically: reads back `undefined`,
+// writes throw "Cannot assign to read only property"). A plain string key
+// satisfies that check and lets `@tracked`/`decorator-transforms` treat the
+// member exactly like an ordinary public tracked field.
+//
+// An *undecorated* private property still gets a second pass: after the
+// class body is rewritten, `hideRenamedProperties` below appends
+// `Object.defineProperty(this, <name>, { ..., enumerable: false })` calls to
+// the constructor for every renamed instance property that has no
+// decorator, so it stays invisible to `for...in`, `Object.keys`,
+// `JSON.stringify` and spread -- closer to real privacy than the plain
+// enumerable field this rewrite produced before. It's still just a string
+// key reachable via `Object.getOwnPropertyNames`/`Reflect.ownKeys` or the
+// generated name, not real encapsulation. A *decorated* private property
+// (e.g. `@tracked #count`) is left exactly as the field-rewrite above
+// produces it -- `decorator-transforms` turns it into an accessor pair on
+// the prototype, not an instance data property, so there's no own property
+// for `Object.defineProperty` to hide in the first place, and forcing one
+// would fight the decorator's own storage instead of complementing it.
+//
+// This second pass only runs against *instance* properties: a static
+// private field lives on the class itself, never reaches the HMR proxy's
+// per-instance `for...in` sync loop, and isn't part of the proxy/delegate
+// problem this file exists to solve, so it's left as the plain enumerable
+// rewrite the first pass already produces.
+//
+// The one thing a generated name can't be checked against is a private
+// member of the *same name* declared by an ancestor/subclass living in a
+// different file (each file's uid generation only sees its own bindings) --
+// deliberately not solved here, since the `hmrPriv<Name>` prefix makes a
+// same-name collision across unrelated classes exceedingly unlikely in
+// practice, and the alternative (whole-program cross-file analysis) is out
+// of proportion to that risk.
+export function renamePrivateClassMembers(babel, classPath, programPath) {
+    var _a;
+    const t = babel.types;
+    if (!hasPrivateMembers(classPath.node.body)) {
+        return;
+    }
+    // `renamedNames` tracks which private member names get rewritten so the
+    // reference-rewriting traversal below only touches references to *this*
+    // class's own renamed members (see the `classPath.traverse` call further
+    // down).
+    const renamedNames = new Set();
+    for (const member of classPath.node.body.body) {
+        if (member.type === 'ClassPrivateProperty' ||
+            member.type === 'ClassPrivateMethod') {
+            renamedNames.add(member.key.id.name);
+        }
+    }
+    // Existing (non-computed, identifier-keyed) member names in this class's
+    // own body, so a generated replacement name can never collide with an
+    // unrelated member already declared here.
+    const usedNames = new Set();
+    for (const member of classPath.node.body.body) {
+        const key = member.key;
+        const computed = member.computed;
+        if (key && !computed && t.isIdentifier(key)) {
+            usedNames.add(key.name);
+        }
+    }
+    const newNames = new Map();
+    const getNewName = (name) => {
+        let known = newNames.get(name);
+        if (known) {
+            return known;
+        }
+        const base = `hmrPriv${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+        let candidate;
+        do {
+            candidate = programPath.scope.generateUidIdentifier(base).name;
+        } while (usedNames.has(candidate));
+        usedNames.add(candidate);
+        newNames.set(name, candidate);
+        return candidate;
+    };
+    // Names of renamed instance properties that should be hidden from
+    // enumeration afterward (see `hideRenamedProperties` below) -- only
+    // undecorated, non-static private *properties* qualify; see the comment
+    // above this function for why decorated and static ones are excluded.
+    const namesToHide = [];
+    // Rename the class's own private declarations directly off the body
+    // array -- not via `classPath.traverse` -- so a nested class's own
+    // (unrelated, possibly same-named) private declarations are never
+    // touched: they simply aren't in this array.
+    for (const memberPath of classPath.get('body').get('body')) {
+        if (memberPath.isClassPrivateProperty()) {
+            const node = memberPath.node;
+            const newName = getNewName(node.key.id.name);
+            memberPath.replaceWith(t.classProperty(t.identifier(newName), node.value, node.typeAnnotation, node.decorators, false, node.static));
+            if (!node.static && !((_a = node.decorators) === null || _a === void 0 ? void 0 : _a.length)) {
+                namesToHide.push(newName);
+            }
+        }
+        else if (memberPath.isClassPrivateMethod()) {
+            const node = memberPath.node;
+            const replacement = t.classMethod(node.kind, t.identifier(getNewName(node.key.id.name)), node.params, node.body, false, node.static, node.generator, node.async);
+            // `t.classMethod`'s builder has no `decorators` parameter -- has to be
+            // assigned after the fact or a decorated private method (e.g. `@action
+            // #foo() {}`) would silently lose its decorator in the rewrite.
+            replacement.decorators = node.decorators;
+            memberPath.replaceWith(replacement);
+        }
+    }
+    // A private name reference found inside a nested class only actually
+    // belongs to `classPath`'s own renamed declaration if no closer-enclosing
+    // class *redeclares* the same name -- private names resolve to the
+    // nearest enclosing class that declares them, same as any other lexical
+    // scoping, so a nested class legitimately shadowing `#secret` with its
+    // own `#secret` must keep referencing its own (native, untouched) field.
+    const declaresOwnPrivate = (cls, name) => cls.body.body.some((member) => (member.type === 'ClassPrivateProperty' ||
+        member.type === 'ClassPrivateMethod') &&
+        member.key.id.name === name);
+    const referenceBelongsToOuterClass = (path, name) => {
+        let enclosing = path.findParent((p) => p.isClass());
+        while (enclosing) {
+            if (enclosing.node === classPath.node) {
+                return true;
+            }
+            if (declaresOwnPrivate(enclosing.node, name)) {
+                return false;
+            }
+            enclosing = enclosing.findParent((p) => p.isClass());
+        }
+        return false;
+    };
+    // Rewrite *references* to the just-renamed names anywhere within the
+    // class, including inside nested classes/closures. Private names are
+    // lexically scoped to their enclosing class body, not to the file, so
+    // code legally references an outer class's private field from inside a
+    // nested class via a captured `this` (e.g. a factory method that builds
+    // and returns a class closing over `self.#secret`). Blanket-skipping
+    // traversal into nested classes -- as an earlier version of this
+    // function did -- left such references as native `#foo` PrivateNames
+    // while the outer declaration was renamed to a Symbol, producing invalid
+    // output ("Private field must be declared in an enclosing class").
+    classPath.traverse({
+        'MemberExpression|OptionalMemberExpression'(path) {
+            const property = path.node.property;
+            if (t.isPrivateName(property) &&
+                renamedNames.has(property.id.name) &&
+                referenceBelongsToOuterClass(path, property.id.name)) {
+                path.node.property = t.identifier(getNewName(property.id.name));
+                path.node.computed = false;
+            }
+        },
+        BinaryExpression(path) {
+            const left = path.node.left;
+            if (path.node.operator === 'in' &&
+                t.isPrivateName(left) &&
+                renamedNames.has(left.id.name) &&
+                referenceBelongsToOuterClass(path, left.id.name)) {
+                path.node.left = t.stringLiteral(getNewName(left.id.name));
+            }
+        },
+    });
+    if (namesToHide.length > 0) {
+        hideRenamedProperties(babel, classPath, namesToHide);
+    }
+}
+// Inserts `Object.defineProperty(this, <name>, { value: this.<name>,
+// writable: true, configurable: true, enumerable: false })` into the class's
+// constructor for every name in `names`, so the renamed properties in
+// `names` stop showing up in `for...in`, `Object.keys`, `JSON.stringify`,
+// and spread -- the same visibility a plain class-field rewrite (which is
+// always enumerable; field syntax has no way to declare otherwise) can't
+// provide on its own.
+//
+// This inserts rather than replacing the field declaration in place so the
+// field keeps initializing at its original position in declaration order --
+// a later field's initializer that legally reads an earlier private field
+// (`#foo = 1; bar = this.#foo + 1;`) still sees the real value, since fields
+// finish initializing (in declaration order, interleaved with each other)
+// before any explicit constructor statement -- including ones this function
+// adds -- ever runs, regardless of where in the constructor body they're
+// inserted.
+//
+// The statements go right after `super(...)` (derived class) or at the very
+// top of the constructor (base class) rather than at the end: all fields
+// are already initialized by that point, and a later `this.<name> = ...`
+// assignment in the constructor only updates the property's `value` -- a
+// plain assignment doesn't reapply `defineProperty`'s `enumerable: false`,
+// so inserting early still reflects any later mutation correctly. Inserting
+// early also means the hide calls still run even if the constructor's own
+// logic contains an early `return` (e.g. a guard clause) after this point --
+// appending at the end would make them dead code on that path.
+//
+// Reads the current value back off `this` (a plain `MemberExpression`)
+// rather than a captured property descriptor: when this class is a subclass
+// of a proxied HMR service, `this` after `super()` is the Proxy from
+// `service-proxy.ts`'s generated constructor, and a plain read goes through
+// its `get` trap, which already forwards correctly to the delegate the
+// property actually lives on.
+function hideRenamedProperties(babel, classPath, names) {
+    const t = babel.types;
+    const hideStatements = names.map((name) => t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('Object'), t.identifier('defineProperty')), [
+        t.thisExpression(),
+        t.stringLiteral(name),
+        t.objectExpression([
+            t.objectProperty(t.identifier('value'), t.memberExpression(t.thisExpression(), t.identifier(name))),
+            t.objectProperty(t.identifier('writable'), t.booleanLiteral(true)),
+            t.objectProperty(t.identifier('configurable'), t.booleanLiteral(true)),
+            t.objectProperty(t.identifier('enumerable'), t.booleanLiteral(false)),
+        ]),
+    ])));
+    const bodyPath = classPath.get('body');
+    const existingCtor = bodyPath
+        .get('body')
+        .find((member) => member.isClassMethod({ kind: 'constructor' }));
+    if (existingCtor) {
+        const ctorBody = existingCtor.get('body');
+        if (!classPath.node.superClass) {
+            ctorBody.unshiftContainer('body', hideStatements);
+            return;
+        }
+        // Only a top-level `super(...)` statement is safe to insert after --
+        // one buried inside a conditional (`if (x) { super(a); } else {
+        // super(b); }`) isn't a single point in the body to anchor on. Fall
+        // back to appending at the end in that case: still not immune to an
+        // early `return`, but at least not a `ReferenceError` from reading
+        // `this` before `super()` has (unconditionally) run.
+        const superCallStatement = ctorBody
+            .get('body')
+            .find((statement) => {
+            if (!statement.isExpressionStatement())
+                return false;
+            const expr = statement.get('expression');
+            if (Array.isArray(expr) || !expr.isCallExpression())
+                return false;
+            const callee = expr.get('callee');
+            return !Array.isArray(callee) && callee.isSuper();
+        });
+        if (superCallStatement) {
+            superCallStatement.insertAfter(hideStatements);
+        }
+        else {
+            ctorBody.pushContainer('body', hideStatements);
+        }
+        return;
+    }
+    // No constructor declared: synthesize one. A derived class's implicit
+    // default constructor forwards every argument to `super` before running
+    // anything else, so match that exactly rather than dropping constructor
+    // arguments the real default constructor would have passed through.
+    const ctorStatements = classPath.node.superClass
+        ? [
+            t.expressionStatement(t.callExpression(t.super(), [t.spreadElement(t.identifier('args'))])),
+            ...hideStatements,
+        ]
+        : hideStatements;
+    bodyPath.unshiftContainer('body', t.classMethod('constructor', t.identifier('constructor'), [t.restElement(t.identifier('args'))], t.blockStatement(ctorStatements)));
+}

package/dist/lib/babel-plugin/service-proxy.d.ts

@@ -0,0 +1,3 @@
+import type * as BabelTypesNamespace from '@babel/types';
+import type * as Babel from '@babel/core';
+export declare function transformServiceExport(babel: typeof Babel, path: Babel.NodePath<BabelTypesNamespace.ExportDefaultDeclaration>, state: Babel.PluginPass): void;