ember-vite-hmr 2.3.0 → 2.4.0

package/dist/lib/babel-plugin.js

@@ -1,143 +1,27 @@
-import * as glimmer from '@glimmer/syntax';
-import { ImportUtil } from 'babel-import-util';
-class HotAstProcessor {
-    constructor() {
-        this.options = {
-            itsStatic: false,
-        };
-        this.counter = 0;
-        this.meta = {
-            locals: new Set(),
-            importVar: null,
-            babelProgram: undefined,
-            importBindings: new Set(),
-        };
-        this.didCreateImportClass = false;
-        this.transform = this.transform.bind(this);
-    }
-    reset() {
-        this.meta.importVar = null;
-        this.meta.babelProgram = undefined;
-        this.meta.importBindings = new Set();
-    }
-    transform(env) {
-        var _a;
-        if (process.env.EMBER_VITE_HMR_ENABLED !== 'true') {
-            return {
-                visitor: {},
-            };
-        }
-        if ((_a = env.filename) === null || _a === void 0 ? void 0 : _a.includes('node_modules')) {
-            return {
-                visitor: {},
-            };
-        }
-        const meta = this.meta;
-        const importVar = env.meta.jsutils.bindExpression(meta.importVar || 'null', null, {
-            nameHint: 'template__imports__',
-        });
-        meta.importVar = meta.importVar || importVar;
-        return {
-            visitor: Object.assign({}, this.buildVisitor({
-                importVar,
-                importBindings: meta.importBindings,
-                babelProgram: meta.babelProgram,
-            })),
-        };
-    }
-    buildVisitor({ importVar, importBindings, babelProgram, }) {
-        const findImport = function findImport(specifier) {
-            return babelProgram.body.find((b) => b.type === 'ImportDeclaration' &&
-                b.specifiers.some((s) => s.local.name === specifier));
-        };
-        const findBlockParams = function (expression, p) {
-            if (p.node.type === 'Template') {
-                return false;
-            }
-            if (p.node &&
-                p.node.type === 'BlockStatement' &&
-                p.node.program.blockParams.includes(expression)) {
-                return true;
-            }
-            const node = p.node;
-            if (node && node.blockParams && node.blockParams.includes(expression)) {
-                return true;
-            }
-            if (!p.parent)
-                return false;
-            return findBlockParams(expression, p.parent);
-        };
-        const visitor = {
-            PathExpression: (node, p) => {
-                var _a, _b;
-                if ((((_a = p.parentNode) === null || _a === void 0 ? void 0 : _a.type) === 'SubExpression' ||
-                    ((_b = p.parentNode) === null || _b === void 0 ? void 0 : _b.type) === 'MustacheStatement') &&
-                    p.parentNode.params.includes(node)) {
-                    return;
-                }
-                const original = node.original.split('.')[0];
-                if (original === 'this')
-                    return;
-                if (original.startsWith('@'))
-                    return;
-                if (original === 'block')
-                    return;
-                if (original.startsWith('this.'))
-                    return;
-                if (findBlockParams(original, p))
-                    return;
-                if (node.original === 'helper' ||
-                    node.original === 'component' ||
-                    node.original === 'modifier') {
-                    // node.original;
-                    const parent = p.parentNode;
-                    if (typeof parent.params[0].original !==
-                        'string') {
-                        return;
-                    }
-                    const original = parent.params[0].original.split('.')[0];
-                    if (original && findBlockParams(original, p))
-                        return;
-                    if (original === null || original === void 0 ? void 0 : original.includes('.'))
-                        return;
-                    if (!original)
-                        return;
-                    if (findImport(original)) {
-                        const param = glimmer.builders.path(`${importVar}.${original}`);
-                        parent.params.splice(0, 1, param);
-                        importBindings.add(original);
-                    }
-                    return;
-                }
-                if (importVar) {
-                    if (findImport(node.original)) {
-                        node.original = `${importVar}.${node.original}`;
-                        node.parts = node.original.split('.');
-                        importBindings.add(original);
-                    }
-                    return;
-                }
-            },
-            ElementNode: (element, p) => {
-                const original = element.tag.split('.')[0];
-                if (findBlockParams(original, p))
-                    return;
-                if (importVar) {
-                    if (findImport(original)) {
-                        element.tag = `${importVar}.${original}`;
-                        p.node.tag = element.tag;
-                        importBindings.add(original);
-                    }
-                    return;
-                }
-            },
-        };
-        return visitor;
-    }
-}
-export const hotAstProcessor = new HotAstProcessor();
+import { hotAstProcessor, finalizeTemplateImports, hmrImportMetadataCache, normalizeHmrCacheFilename, } from './babel-plugin/template-imports.js';
+import { renamePrivateClassMembers } from './babel-plugin/private-members.js';
+import { transformServiceExport } from './babel-plugin/service-proxy.js';
+// `ember-vite-hmr/lib/babel-plugin` is a published subpath import (see
+// test-app/babel.config.mjs), so this file's module path and its exports
+// (this default export, and the `hotAstProcessor` / `hmrImportMetadataCache`
+// / `normalizeHmrCacheFilename` re-exports below) have to keep resolving
+// exactly as-is -- the actual logic lives in ./babel-plugin/*, split by
+// concern:
+//  - template-imports.ts: rewrites template references to imported
+//    components/helpers/modifiers through a per-module tracked class, so
+//    swapping which module a virtual HMR wrapper resolves to is visible to
+//    templates (registered separately as an ember-template-compilation
+//    transform via the `hotAstProcessor` export below), and shares the
+//    computed import metadata with lib/hmr.ts via `hmrImportMetadataCache`.
+//  - private-members.ts: rewrites every native `#private` class member the
+//    app's own source declares to a plain, uniquely-named property, so it
+//    reads/writes correctly through the service proxy below regardless of
+//    what `this` is at the call site.
+//  - service-proxy.ts: rewrites `export default class X extends Service`
+//    into a generated HMR proxy class that swaps its delegate instance on
+//    every accepted update.
+export { hotAstProcessor, hmrImportMetadataCache, normalizeHmrCacheFilename };
 export default function hotReplaceAst(babel) {
-    const t = babel.types;
     return {
         name: 'a-hot-reload-imports',
         pre(file) {
@@ -145,269 +29,31 @@ export default function hotReplaceAst(babel) {
             hotAstProcessor.meta.babelProgram = file.ast.program;
         },
         visitor: {
-            ExportDefaultDeclaration(path, state) {
-                var _a, _b;
+            // Runs on *every* class the app's own source defines, independent of
+            // whether it's a service, a service's ancestor, or unrelated to the
+            // HMR proxy machinery entirely -- see `renamePrivateClassMembers`'s
+            // own doc comment for why this can't be scoped any tighter than that
+            // without whole-program analysis. This also visits the `proxyClass`
+            // (and, for an inline export, the `originalClass` copy)
+            // `transformServiceExport` generates below -- harmless today only
+            // because generated proxy classes never declare private members of
+            // their own; if that ever changes, this visitor would rename them
+            // too.
+            Class(path, state) {
+                var _a;
                 if (process.env.EMBER_VITE_HMR_ENABLED !== 'true') {
                     return;
                 }
                 if ((_a = state.filename) === null || _a === void 0 ? void 0 : _a.includes('node_modules')) {
                     return;
                 }
-                // Check if this is a service file (normalize path for cross-platform compatibility)
-                const normalizedFilename = (_b = state.filename) === null || _b === void 0 ? void 0 : _b.replace(/\\/g, '/');
-                if (!(normalizedFilename === null || normalizedFilename === void 0 ? void 0 : normalizedFilename.includes('/services/'))) {
-                    return;
-                }
-                const declaration = path.node.declaration;
-                // Handle both inline class declaration and identifier reference
-                let classDeclaration = null;
-                let classIdentifier = null;
-                if (declaration.type === 'ClassDeclaration' && declaration.id) {
-                    // Case 1: export default class MyService extends Service { ... }
-                    classDeclaration = declaration;
-                    classIdentifier = declaration.id;
-                }
-                else if (declaration.type === 'Identifier') {
-                    // Case 2: class MyService extends Service { ... } \n export default MyService;
-                    const binding = path.scope.getBinding(declaration.name);
-                    if (binding && binding.path.isClassDeclaration()) {
-                        classDeclaration = binding.path
-                            .node;
-                        classIdentifier = classDeclaration.id;
-                    }
-                }
-                if (!classDeclaration || !classIdentifier) {
-                    return;
-                }
-                if (classIdentifier.name.endsWith('HmrProxy')) {
-                    return;
-                }
-                // Check if it extends Service
-                const superClass = classDeclaration.superClass;
-                if (!superClass ||
-                    ((superClass.type !== 'Identifier' ||
-                        superClass.name !== 'Service') &&
-                        superClass.type !== 'MemberExpression')) {
-                    return;
-                }
-                // Get the program path for ImportUtil
                 const programPath = path.findParent((p) => p.isProgram());
                 if (!programPath) {
                     return;
                 }
-                const util = new ImportUtil(babel, programPath);
-                const tracked = util.import(programPath, '@glimmer/tracking', 'tracked');
-                const Service = util.import(programPath, '@ember/service', 'default');
-                const originalClassName = classIdentifier.name;
-                const proxyClassName = `${originalClassName}HmrProxy`;
-                // Keep the original class as-is, just remove it from export
-                // We'll add it back as a non-exported class
-                const babelTemplate = babel.template;
-                // The live proxy instance and the latest accepted implementation must
-                // live on `import.meta.hot.data`, not in a module-scope `let`: Vite
-                // guarantees that object (and only that object) survives across a
-                // module's hot re-evaluations. A component's `@service` injection can
-                // end up constructing the proxy against a *later* re-evaluation of
-                // this module than the one whose `import.meta.hot.accept` closure
-                // captured a module-scope variable — the closure and the constructor
-                // would then silently operate on two disconnected variable bindings
-                // (a duplicate-module symptom), and the HMR swap would never reach
-                // the instance actually rendered.
-                const ctorBody = babelTemplate.statements(`
-            super(...args);
-            this._owner = args[0];
-            const Impl = (import.meta.hot && import.meta.hot.data._impl) || ${proxyClassName}.Impl;
-            this._delegate = new Impl(this._owner);
-            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, receiver) {
-                if (prop === '_delegate') {
-                  return target._delegate;
-                }
-                // 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(`
-            super.willDestroy();
-            this._delegate.willDestroy();
-            if (import.meta.hot && import.meta.hot.data._proxy === this) {
-              import.meta.hot.data._proxy = undefined;
-            }
-          `)();
-                // Create the HMR proxy service class
-                const proxyClass = t.classDeclaration(t.identifier(proxyClassName), Service, t.classBody([
-                    // static Impl = OriginalService (reference to the original class)
-                    t.classProperty(t.identifier('Impl'), t.identifier(originalClassName), null, null, false, true),
-                    // @tracked _delegate
-                    t.classProperty(t.identifier('_delegate'), null, null, [t.decorator(tracked)], false, false),
-                    t.classMethod('constructor', t.identifier('constructor'), [t.restElement(t.identifier('args'))], t.blockStatement(ctorBody)),
-                    t.classMethod('method', t.identifier('willDestroy'), [], t.blockStatement(willDestroyBody)),
-                ]));
-                // For Case 1 (inline class), we need to keep the class as non-exported
-                // For Case 2 (separate declaration), the class already exists, so we don't recreate it
-                if (declaration.type === 'ClassDeclaration') {
-                    // Case 1: Inline class export - create a non-exported version
-                    const originalClass = t.classDeclaration(classIdentifier, classDeclaration.superClass, classDeclaration.body, classDeclaration.decorators || []);
-                    // Replace the export with all the necessary declarations
-                    // IMPORTANT: Class must be declared BEFORE the proxy class that references it
-                    path.replaceWithMultiple([
-                        originalClass, // The original class (no longer exported) - MUST BE FIRST
-                        t.exportDefaultDeclaration(proxyClass), // Export the proxy class
-                    ]);
-                }
-                else {
-                    // Case 2: Separate declaration - class already exists, just replace the export
-                    path.replaceWithMultiple([
-                        t.exportDefaultDeclaration(proxyClass), // Export the proxy class
-                    ]);
-                }
-                // Add HMR code after the export using babel template
-                if (programPath) {
-                    const hmrCode = `
-            if (import.meta.hot) {
-              import.meta.hot.accept((newModule) => {
-                const NewImpl = newModule?.default?.Impl;
-                if (!NewImpl) {
-                  return;
-                }
-
-                // Remember the latest accepted implementation so a proxy
-                // constructed *after* this update (its instantiation raced
-                // behind the HMR swap) still picks up the new class instead
-                // of the stale one captured at module-evaluation time.
-                import.meta.hot.data._impl = NewImpl;
-
-                const proxy = import.meta.hot.data._proxy;
-                if (!proxy) {
-                  // No instance has been created yet; the next construction
-                  // will read import.meta.hot.data._impl above.
-                  return;
-                }
-
-                const oldDelegate = proxy._delegate;
-                const newDelegate = new NewImpl(proxy._owner);
-                proxy._delegate = newDelegate;
-
-                // Sync state from old to new while keeping new implementation defaults
-                for (const key in oldDelegate) {
-                  const descriptor =
-                    Object.getOwnPropertyDescriptor(oldDelegate, key) ||
-                    Object.getOwnPropertyDescriptor(Object.getPrototypeOf(oldDelegate), key);
-                  const hasOwnDefault = Object.prototype.hasOwnProperty.call(newDelegate, key);
-                  const currentValue = newDelegate[key];
-                  const previousValue = oldDelegate[key];
-
-                  // Skip Service instances - they should not be synced
-                  if (previousValue instanceof Service) {
-                    continue;
-                  }
-
-                  // 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;
-                  }
-
-                  const shouldSync =
-                    !!descriptor &&
-                    (descriptor.writable || descriptor.set || Object.prototype.hasOwnProperty.call(oldDelegate, key)) &&
-                    (!hasOwnDefault || currentValue === previousValue);
-
-                  if (shouldSync) {
-                    try {
-                      newDelegate[key] = previousValue;
-                    } catch (e) {
-                      // Skip non-writable properties
-                    }
-                  }
-                }
-
-                newDelegate._hmrAccepted?.(oldDelegate);
-
-                if (oldDelegate.willDestroy) {
-                  oldDelegate.willDestroy();
-                }
-              });
-            }
-          `;
-                    const template = babel.template.statements(hmrCode);
-                    programPath.pushContainer('body', template());
-                }
+                renamePrivateClassMembers(babel, path, programPath);
             },
-            Program(path, state) {
+            ExportDefaultDeclaration(path, state) {
                 var _a;
                 if (process.env.EMBER_VITE_HMR_ENABLED !== 'true') {
                     return;
@@ -415,37 +61,17 @@ export default function hotReplaceAst(babel) {
                 if ((_a = state.filename) === null || _a === void 0 ? void 0 : _a.includes('node_modules')) {
                     return;
                 }
-                if (!hotAstProcessor.meta.importVar ||
-                    hotAstProcessor.meta.importBindings.size === 0) {
+                transformServiceExport(babel, path, state);
+            },
+            Program(path, state) {
+                var _a;
+                if (process.env.EMBER_VITE_HMR_ENABLED !== 'true') {
                     return;
                 }
-                const util = new ImportUtil(babel, path);
-                const tracked = util.import(path, '@glimmer/tracking', 'tracked');
-                util.import(path, '@glimmer/component', 'default');
-                const klass = t.classExpression(path.scope.generateUidIdentifier('Imports'), null, t.classBody([]));
-                const bindings = [...hotAstProcessor.meta.importBindings].sort();
-                for (const local of bindings) {
-                    klass.body.body.push(t.classProperty(t.identifier(local), t.identifier(local), null, [
-                        t.decorator(tracked),
-                    ]));
+                if ((_a = state.filename) === null || _a === void 0 ? void 0 : _a.includes('node_modules')) {
+                    return;
                 }
-                const newExp = t.newExpression(klass, []);
-                const assign = t.assignmentExpression('=', t.identifier(hotAstProcessor.meta.importVar), newExp);
-                const varDeclaration = path.node.body.findIndex((e) => e.type === 'VariableDeclaration' &&
-                    e.declarations[0].id.name ===
-                        hotAstProcessor.meta.importVar) + 1;
-                const lastImportIndex = path.node.body.findLastIndex((e) => e.type === 'ImportDeclaration') + 1;
-                path.node.body.splice(Math.max(varDeclaration, lastImportIndex), 0, t.expressionStatement(assign));
-                // Export metadata about tracked imports for hmr.ts to use
-                const importMetadata = t.variableDeclaration('const', [
-                    t.variableDeclarator(t.identifier('__hmr_import_metadata__'), t.objectExpression([
-                        t.objectProperty(t.identifier('importVar'), t.stringLiteral(hotAstProcessor.meta.importVar)),
-                        t.objectProperty(t.identifier('bindings'), t.arrayExpression(bindings.map((b) => t.stringLiteral(b)))),
-                    ])),
-                ]);
-                const exportMetadata = t.exportNamedDeclaration(importMetadata, []);
-                path.node.body.push(exportMetadata);
-                path.scope.crawl();
+                finalizeTemplateImports(babel, path, state.filename);
             },
         },
     };