ember-vite-hmr 0.1.0

package/README.md

@@ -0,0 +1,38 @@
+ember-vite-hmr
+
+Ember Vite Hmr plugin.
+
+this can hot reload
+
+- helpers
+- modifiers
+- components + templates, fcct components and its deps
+- routes/controllers/route-templates (although it refreshes the whole route and thus looses all state)
+
+it cannot hot reload local properties that turn out to be helpers/modifiers/components.
+
+## Installation
+
+```
+ember install ember-vite-hmr
+```
+
+## Usage
+
+update your `vite.config.mjs` with
+
+```js
+import { hmr } from 'ember-vite-hmr';
+...hmr
+plugins: [
+  ...hmr(resolver())
+]
+```
+
+## Contributing
+
+See the [Contributing](CONTRIBUTING.md) guide for details.
+
+## License
+
+This project is licensed under the [MIT License](LICENSE.md).

package/addon-main.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+const { addonV1Shim } = require('@embroider/addon-shim');
+const path = require('path');
+module.exports = addonV1Shim(__dirname);
+const included = module.exports.included;
+
+Object.assign(module.exports, {
+  _getBabelOptions() {
+    const parentOptions = this.parent && this.parent.options;
+    const appOptions = this.app && this.app.options;
+    const addonOptions = parentOptions || appOptions || {};
+
+    addonOptions.babel = addonOptions.babel || {};
+    addonOptions.babel.plugins = addonOptions.babel.plugins || [];
+    return addonOptions.babel;
+  },
+  included(...args) {
+    this._getBabelOptions().plugins.push([require.resolve('./dist/lib/babel-plugin.js'), { v: 4, appName: this.app.name }]);
+    this._super.included; // need to access this somehow? otherwise it fails later on...
+
+    let astPlugin = this._buildPlugin();
+    astPlugin.parallelBabel = {
+      requireFile: __filename,
+      buildUsing: '_buildPlugin',
+      params: {}
+    };
+    const compatAppBuilder = require.resolve('@embroider/compat/src/compat-app-builder', { paths: [process.cwd()] });
+    const CompatAppBuilder = require(compatAppBuilder).CompatAppBuilder;
+    const etcOptions = CompatAppBuilder.prototype.etcOptions;
+    CompatAppBuilder.prototype.etcOptions = function (...args) {
+      const opts = etcOptions.call(this, ...args);
+      opts.transforms.push(astPlugin);
+      return opts;
+    }
+    included.call(this, ...args);
+  },
+
+  _buildPlugin() {
+    const hotAstProcessor = require('./dist/lib/babel-plugin').hotAstProcessor;
+    return hotAstProcessor.transform.bind(hotAstProcessor);
+  },
+})
+

package/dist/_app_/initializers/webpack-hot-reload.js

@@ -0,0 +1 @@
+export { default } from "ember-vite-hmr/initializers/webpack-hot-reload";

package/dist/_app_/services/webpack-hot-reload.js

@@ -0,0 +1 @@
+export { default } from "ember-vite-hmr/services/webpack-hot-reload";

package/dist/initializers/webpack-hot-reload.js

@@ -0,0 +1,15 @@
+function initialize(application) {
+  application.__container__.lookup('service:webpack-hot-reload');
+  const resolver = application.__registry__.resolver._fallback || application.__registry__.resolver;
+  const resolverResolve = resolver.resolve;
+  resolver.resolve = function (name) {
+    name = name.replace(/--hot-version--.*$/, '');
+    return resolverResolve.call(this, name);
+  };
+}
+var webpackHotReload = {
+  initialize
+};
+
+export { webpackHotReload as default, initialize };
+//# sourceMappingURL=webpack-hot-reload.js.map

package/dist/initializers/webpack-hot-reload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack-hot-reload.js","sources":["../../src/initializers/webpack-hot-reload.ts"],"sourcesContent":["export function initialize(application) {\n  application.__container__.lookup('service:webpack-hot-reload');\n  const resolver =\n    application.__registry__.resolver._fallback ||\n    application.__registry__.resolver;\n  const resolverResolve = resolver.resolve;\n  resolver.resolve = function (name) {\n    name = name.replace(/--hot-version--.*$/, '');\n    return resolverResolve.call(this, name);\n  };\n}\n\nexport default {\n  initialize,\n};\n"],"names":["initialize","application","__container__","lookup","resolver","__registry__","_fallback","resolverResolve","resolve","name","replace","call"],"mappings":"AAAO,SAASA,UAAUA,CAACC,WAAW,EAAE;AACtCA,EAAAA,WAAW,CAACC,aAAa,CAACC,MAAM,CAAC,4BAA4B,CAAC,CAAA;AAC9D,EAAA,MAAMC,QAAQ,GACZH,WAAW,CAACI,YAAY,CAACD,QAAQ,CAACE,SAAS,IAC3CL,WAAW,CAACI,YAAY,CAACD,QAAQ,CAAA;AACnC,EAAA,MAAMG,eAAe,GAAGH,QAAQ,CAACI,OAAO,CAAA;AACxCJ,EAAAA,QAAQ,CAACI,OAAO,GAAG,UAAUC,IAAI,EAAE;IACjCA,IAAI,GAAGA,IAAI,CAACC,OAAO,CAAC,oBAAoB,EAAE,EAAE,CAAC,CAAA;AAC7C,IAAA,OAAOH,eAAe,CAACI,IAAI,CAAC,IAAI,EAAEF,IAAI,CAAC,CAAA;GACxC,CAAA;AACH,CAAA;AAEA,uBAAe;AACbT,EAAAA,UAAAA;AACF,CAAC;;;;"}

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

@@ -0,0 +1,32 @@
+import { PluginObj } from '@babel/core';
+import type * as BabelTypesNamespace from '@babel/types';
+import * as glimmer from '@glimmer/syntax';
+import { ASTPluginEnvironment } from '@glimmer/syntax';
+export type BabelTypes = typeof BabelTypesNamespace;
+declare class HotAstProcessor {
+    options: {
+        itsStatic: boolean;
+    };
+    counter: number;
+    meta: {
+        usedImports: any[];
+        importVar: any;
+    };
+    transform(env: ASTPluginEnvironment): {
+        visitor: glimmer.NodeVisitor;
+    };
+    buildVisitor({ importVar, imports, changes, hotReplaced, usedImports }: {
+        importVar: any;
+        imports: any;
+        changes: any;
+        hotReplaced: any;
+        usedImports: any;
+    }): glimmer.NodeVisitor;
+    replaceInAst(ast: glimmer.ASTv1.Template, importVar?: string, imports?: string[]): Set<unknown>;
+    processAst(contents: string, importVar?: string, imports?: string[]): string;
+}
+export declare const hotAstProcessor: HotAstProcessor;
+export default function hotReplaceAst({ types: t }: {
+    types: BabelTypes;
+}, options: any): PluginObj<import("@babel/core").PluginPass>;
+export {};

package/dist/lib/babel-plugin.js

@@ -0,0 +1,502 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hotAstProcessor = void 0;
+const core_1 = require("@babel/core");
+const glimmer = __importStar(require("@glimmer/syntax"));
+const builtInComponents = ['LinkTo'];
+const builtInHelpers = [
+    '-get-dynamic-var',
+    '-element',
+    '-lf-get-outlet-state',
+    '-in-element',
+    'in-element',
+    '-with-dynamic-vars',
+    'action',
+    'array',
+    'component',
+    'concat',
+    'debugger',
+    'each',
+    'each-in',
+    'fn',
+    'get',
+    'has-block',
+    'has-block-params',
+    'hasBlock',
+    'hasBlockParams',
+    'hash',
+    'if',
+    'input',
+    'let',
+    'link-to',
+    'loc',
+    'log',
+    'mount',
+    'mut',
+    'on',
+    'outlet',
+    'partial',
+    'query-params',
+    'readonly',
+    'textarea',
+    'unbound',
+    'unless',
+    'with',
+    'yield',
+    'modifier',
+    'helper',
+];
+function dasherize(str) {
+    return str
+        .trim()
+        .split(/\.?(?=[A-Z])/)
+        .join('-')
+        .toLowerCase();
+}
+class HotAstProcessor {
+    constructor() {
+        this.options = {
+            itsStatic: false,
+        };
+        this.counter = 0;
+        this.meta = {
+            usedImports: [],
+            importVar: null,
+        };
+    }
+    transform(env) {
+        if (!this.meta.importVar)
+            return {
+                visitor: {},
+            };
+        const meta = this.meta;
+        meta.usedImports = new Set();
+        const usedImports = this.meta.usedImports;
+        const imports = [...env.locals];
+        if (!meta.importVar) {
+            return {
+                visitor: {},
+            };
+        }
+        const importVar = meta.importVar.name;
+        env.locals.length = 0;
+        env.locals.push(importVar);
+        return {
+            visitor: this.buildVisitor({
+                importVar,
+                imports,
+                changes: [],
+                usedImports,
+            }),
+        };
+    }
+    buildVisitor({ importVar, imports, changes, hotReplaced, usedImports }) {
+        const findBlockParams = function (expression, p) {
+            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) => {
+                if ((p.parentNode?.type === 'SubExpression' ||
+                    p.parentNode?.type === 'MustacheStatement') &&
+                    p.parentNode.params.includes(node)) {
+                    return;
+                }
+                if (node.original === 'this')
+                    return;
+                if (node.original.startsWith('@'))
+                    return;
+                if (node.original === 'block')
+                    return;
+                if (node.original.startsWith('this.'))
+                    return;
+                if (findBlockParams(node.original.split('.')[0], p))
+                    return;
+                if (importVar) {
+                    if (imports.includes(node.original)) {
+                        usedImports.add(node.original);
+                        node.original = `${importVar}.${node.original}`;
+                        node.parts = node.original.split('.');
+                    }
+                    return;
+                }
+                const params = [];
+                const blockParams = [];
+                const letBlock = glimmer.builders.path('let');
+                if (node.original === 'helper' ||
+                    node.original === 'component' ||
+                    node.original === 'modifier') {
+                    if (p.parentNode.params[0].original &&
+                        findBlockParams(p.parentNode.params[0].original.split('.')[0], p))
+                        return;
+                    if (p.parentNode.params[0].original?.includes('.'))
+                        return;
+                    const sub = glimmer.builders.sexpr(node.original, [p.parentNode.params[0]], glimmer.builders.hash([]));
+                    const param = glimmer.builders.sexpr('webpack-hot-reload', [sub], glimmer.builders.hash([
+                        glimmer.builders.pair('type', glimmer.builders.string(node.original)),
+                    ]));
+                    p.parentNode.params.splice(0, 1);
+                    params.push(param);
+                    const name = node.original + '_' + this.counter;
+                    blockParams.push(name);
+                    node.type = 'PathExpression';
+                    node.original = name;
+                    const block = glimmer.builders.blockItself([], blockParams);
+                    const b = glimmer.builders.block(letBlock, params, null, block);
+                    changes.push(b);
+                    this.counter++;
+                    return;
+                }
+                if (builtInHelpers.includes(node.original)) {
+                    return;
+                }
+                if (!builtInHelpers.includes(node.original)) {
+                    if (p.parentNode?.type === 'ElementModifierStatement')
+                        return;
+                }
+                const firstLetter = node.original.split('.').slice(-1)[0][0];
+                let type = 'helper';
+                if ((this.options.itsStatic &&
+                    p.parentNode?.type === 'MustacheStatement') ||
+                    firstLetter === firstLetter.toUpperCase()) {
+                    type = 'component';
+                }
+                const sub = glimmer.builders.sexpr(type, [
+                    glimmer.builders.string(node.original),
+                    ...(p.parentNode.type === 'SubExpression' ? p.parentNode.params : []),
+                ]);
+                const param = glimmer.builders.sexpr('webpack-hot-reload', [sub], glimmer.builders.hash([
+                    glimmer.builders.pair('type', glimmer.builders.string(type)),
+                ]));
+                params.push(param);
+                const name = type + '_' + this.counter;
+                blockParams.push(name);
+                node.type = 'PathExpression';
+                node.original = name;
+                if (!params.length)
+                    return;
+                const block = glimmer.builders.blockItself([], blockParams);
+                const b = glimmer.builders.block(letBlock, params, null, block);
+                changes.push(b);
+                this.counter++;
+            },
+            ElementNode: (element, p) => {
+                const params = [];
+                const blockParams = [];
+                const letBlock = glimmer.builders.path('let');
+                element.modifiers.forEach((modifier) => {
+                    if (importVar) {
+                        return;
+                    }
+                    if (!modifier.path.original)
+                        return;
+                    if (modifier.path.original && modifier.path.original.includes('.'))
+                        return;
+                    if (builtInHelpers.includes(modifier.path.original)) {
+                        return;
+                    }
+                    const sub = glimmer.builders.sexpr('modifier', [
+                        {
+                            ...((modifier.path.original &&
+                                glimmer.builders.string(modifier.path.original)) ||
+                                modifier.path),
+                        },
+                    ]);
+                    const param = glimmer.builders.sexpr('webpack-hot-reload', [sub], glimmer.builders.hash([
+                        glimmer.builders.pair('type', glimmer.builders.string('modifier')),
+                    ]));
+                    params.push(param);
+                    const name = 'modifier_' + this.counter;
+                    blockParams.push(name);
+                    modifier.path.type = 'PathExpression';
+                    modifier.path.original = 'modifier_' + this.counter;
+                    this.counter++;
+                });
+                if (findBlockParams(element.tag.split('.')[0], p))
+                    return;
+                if (importVar) {
+                    if (imports.includes(element.tag)) {
+                        usedImports.add(element.tag);
+                        element.tag = `${importVar}.${element.tag}`;
+                    }
+                    return;
+                }
+                if (builtInComponents.includes(element.tag)) {
+                    return;
+                }
+                if (element.tag[0] === element.tag[0].toUpperCase()) {
+                    const sub = glimmer.builders.sexpr('component', [
+                        glimmer.builders.string(dasherize(element.tag)),
+                    ]);
+                    const param = glimmer.builders.sexpr('webpack-hot-reload', [sub], glimmer.builders.hash([
+                        glimmer.builders.pair('type', glimmer.builders.string('component')),
+                    ]));
+                    params.push(param);
+                    const name = 'Component_' + this.counter;
+                    blockParams.push(name);
+                    element.tag = name;
+                }
+                const block = glimmer.builders.blockItself([], blockParams);
+                if (!params.length)
+                    return;
+                const b = glimmer.builders.block(letBlock, params, null, block);
+                changes.push(b);
+                this.counter++;
+            },
+            Program: {
+                exit(program) { },
+            },
+        };
+        return visitor;
+    }
+    replaceInAst(ast, importVar, imports) {
+        const usedImports = new Set();
+        const hotReplaced = {
+            components: new Set(),
+            helpers: new Set(),
+            modifiers: new Set(),
+            others: new Set(),
+            info: {
+                components: {},
+                helpers: {},
+                modifiers: {},
+            },
+        };
+        const changes = [];
+        const visitor = this.buildVisitor({
+            importVar,
+            imports,
+            changes,
+            hotReplaced,
+            usedImports,
+        });
+        glimmer.traverse(ast, visitor);
+        const program = ast;
+        let body = [...program.body];
+        for (const letBlock of changes) {
+            letBlock.program.body = body;
+            body = [letBlock];
+        }
+        program.body.length = 0;
+        program.body.push(...body);
+        return usedImports;
+    }
+    processAst(contents, importVar, imports) {
+        const ast = glimmer.preprocess(contents);
+        this.counter = 0;
+        this.usedImports = this.replaceInAst(ast, importVar, imports);
+        return glimmer.print(ast);
+    }
+}
+exports.hotAstProcessor = new HotAstProcessor();
+function hotReplaceAst({ types: t }, options) {
+    let imports = [];
+    let importMap = {};
+    let tracked;
+    let importVar;
+    let importsKlass;
+    let templateImportSpecifier = '';
+    return {
+        name: 'hot-reload-imports',
+        visitor: {
+            Program: {
+                enter(path) {
+                    templateImportSpecifier = '';
+                    importVar = null;
+                    tracked = null;
+                    importMap = {};
+                    imports = [];
+                    exports.hotAstProcessor.meta.usedImports = [];
+                    exports.hotAstProcessor.meta.importVar = null;
+                    const filename = path.hub.file.opts.filename.split('?')[0];
+                    if (!filename.endsWith('.hbs') &&
+                        !filename.endsWith('.gts') &&
+                        !filename.endsWith('.gjs')) {
+                        return;
+                    }
+                    if (!filename.includes('rewritten-app')) {
+                        return;
+                    }
+                    const node = path.node;
+                    const templateImport = node.body.find((i) => i.type === 'ImportDeclaration' &&
+                        i.source.value === '@ember/template-compiler');
+                    if (templateImport) {
+                        const def = templateImport.specifiers[0];
+                        templateImportSpecifier = def.local.name;
+                    }
+                    tracked = path.scope.generateUidIdentifier('tracked');
+                    importVar = path.scope.generateUidIdentifier('__imports__');
+                    exports.hotAstProcessor.meta.importVar = importVar;
+                    node.body.splice(0, 0, t.importDeclaration([t.importSpecifier(tracked, t.identifier('tracked'))], t.stringLiteral('@glimmer/tracking')));
+                    let usedImports = new Set();
+                    const addedIds = new Set();
+                    path.traverse({
+                        ImportDeclaration: function (path) {
+                            path.node.specifiers.forEach(function (s) {
+                                imports.push(s.local.name);
+                                importMap[s.local.name] = {
+                                    source: path.node.source.value,
+                                    specifiers: path.node.specifiers,
+                                };
+                            });
+                        },
+                        Identifier(path) {
+                            if (addedIds.has(path.node)) {
+                                path.scope
+                                    .getBinding(path.node.name)
+                                    ?.referencePaths.push(path);
+                            }
+                        },
+                        CallExpression(path) {
+                            const call = path.node;
+                            if (templateImportSpecifier &&
+                                call.callee.name ===
+                                    templateImportSpecifier &&
+                                (call.arguments[0]?.type === 'StringLiteral' ||
+                                    call.arguments[0]?.type === 'TemplateLiteral')) {
+                                if (call.arguments[0].type === 'StringLiteral') {
+                                    call.arguments[0].value = exports.hotAstProcessor.processAst(call.arguments[0].value, importVar.name, imports);
+                                    exports.hotAstProcessor.usedImports.forEach(usedImports.add, usedImports);
+                                }
+                                if (call.arguments[0].type === 'TemplateLiteral' &&
+                                    call.arguments[0].quasis[0]) {
+                                    call.arguments[0].quasis[0].value.raw =
+                                        exports.hotAstProcessor.processAst(call.arguments[0].quasis[0].value.raw, importVar.name, imports);
+                                    exports.hotAstProcessor.usedImports.forEach(usedImports.add, usedImports);
+                                }
+                            }
+                        },
+                    });
+                    const lastImport = [...node.body]
+                        .reverse()
+                        .find((x) => x.type === 'ImportDeclaration');
+                    const idx = node.body.indexOf(lastImport);
+                    const importsVar = t.variableDeclaration('let', [
+                        t.variableDeclarator(importVar),
+                    ]);
+                    importsKlass = t.classExpression(path.scope.generateUidIdentifier('Imports'), null, t.classBody([...usedImports].map((i) => {
+                        const x = t.identifier(i);
+                        addedIds.add(x);
+                        return t.classProperty(t.identifier(i), x, null, [
+                            t.decorator(tracked),
+                        ]);
+                    })));
+                    const assignment = t.expressionStatement(t.assignmentExpression('=', importVar, t.newExpression(importsKlass, [])));
+                    const hotAccepts = [];
+                    for (const imp of [...usedImports]) {
+                        const { source, specifiers } = importMap[imp];
+                        const specifier = specifiers.find((s) => s.local.name === imp);
+                        const specifierName = specifier.imported?.name ||
+                            specifier.imported?.value ||
+                            'default';
+                        const ast = (0, core_1.parse)(`import.meta.hot.accept('${source}', (module) => (${importVar.name}.${imp}=module['${specifierName}']))`);
+                        const impHot = ast?.program.body[0];
+                        hotAccepts.push(impHot);
+                    }
+                    const ifHot = t.ifStatement(t.memberExpression(t.metaProperty(t.identifier('import'), t.identifier('meta')), t.identifier('hot')), t.blockStatement([assignment, ...hotAccepts]));
+                    node.body.splice(idx, 0, importsVar);
+                    node.body.push(ifHot);
+                },
+                exit(path, state) {
+                    const filename = path.hub.file.opts.filename.split('?')[0];
+                    if (!filename.includes('rewritten-app')) {
+                        return;
+                    }
+                    if (!filename.endsWith('.hbs') &&
+                        !filename.endsWith('.gts') &&
+                        !filename.endsWith('.gjs')) {
+                        return;
+                    }
+                    path.traverse({
+                        ImportDeclaration: function (path) {
+                            path.node.specifiers.forEach(function (s) {
+                                imports.push(s.local.name);
+                                importMap[s.local.name] = {
+                                    source: path.node.source.value,
+                                    specifiers: path.node.specifiers,
+                                };
+                            });
+                        },
+                    });
+                    const node = path.node;
+                    const usedImports = exports.hotAstProcessor.meta.usedImports;
+                    if (usedImports) {
+                        const lastImport = [...node.body]
+                            .reverse()
+                            .find((x) => x.type === 'ImportDeclaration');
+                        const idx = node.body.indexOf(lastImport);
+                        const assignment = node.body.at(-1);
+                        node.body.splice(-1, 1);
+                        node.body.splice(idx, 0, assignment);
+                        const hotAccepts = [];
+                        for (const imp of [...usedImports]) {
+                            const { source, specifiers } = importMap[imp];
+                            const specifier = specifiers.find((s) => s.local.name === imp);
+                            const specifierName = specifier.imported?.name ||
+                                specifier.imported?.value ||
+                                'default';
+                            const ast = (0, core_1.parse)(`import.meta.hot.accept('${source}', (module) => (${importVar.name}.${imp}=module['${specifierName}']))`);
+                            const impHot = ast?.program.body[0];
+                            hotAccepts.push(impHot);
+                        }
+                        const ifHot = t.ifStatement(t.memberExpression(t.metaProperty(t.identifier('import'), t.identifier('meta')), t.identifier('hot')), t.blockStatement([...hotAccepts]));
+                        node.body.push(ifHot);
+                        importsKlass.body.body.length = 0;
+                    }
+                },
+            },
+            CallExpression: {
+                exit(path, state) {
+                    const filename = path.hub.file.opts.filename.split('?')[0];
+                    if (filename.endsWith('.hbs')) {
+                        const usedImports = exports.hotAstProcessor.meta.usedImports;
+                        [...usedImports].map((i) => {
+                            if (importsKlass.body.body.find((b) => b.key.name === i)) {
+                                return;
+                            }
+                            const x = t.identifier(i);
+                            const klassProp = t.classProperty(t.identifier(i), x, null, [
+                                t.decorator(tracked),
+                            ]);
+                            importsKlass.body.body.push(klassProp);
+                        });
+                    }
+                },
+            },
+        },
+    };
+}
+exports.default = hotReplaceAst;

package/dist/lib/hmr.d.ts

@@ -0,0 +1,5 @@
+export default function (resolver: any): {
+    name: string;
+    enforce: string;
+    transform(source: any, id: any): any;
+};

package/dist/lib/hmr.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function transform({ resolver, resourcePath, plugin }) {
+    const resourcePath = resourcePath.replace(/\\/g, '/').split('?')[0];
+    const supportedPaths = ['routers', 'controllers', 'routes'];
+    const supportedFileNames = [
+        'router.js',
+        'router.ts',
+        'router.gts',
+        'router.gjs',
+        'controller.js',
+        'controller.ts',
+    ];
+    if (resourcePath.endsWith('.hbs') ||
+        resourcePath.endsWith('.gjs') ||
+        resourcePath.endsWith('.gts')) {
+        const result = [...source.matchAll(/import.meta.hot.accept\(\'([^']+)\'/g)];
+        for (const resultElement of result) {
+            const dep = resultElement[1];
+            const resolved = await resolver.resolveId.call(plugin, dep, resourcePath, {});
+            let id = resolved.id;
+            if (id.includes('rewritten-app')) {
+                id = id.split('rewritten-app')[1];
+            }
+            if (path.resolve(id).replace(/\\/g, '/') === id && path.isAbsolute(id)) {
+                if (!id.startsWith('/')) {
+                    id = '/' + id;
+                }
+                id = '/@fs' + id;
+            }
+            source = source.replace(`import.meta.hot.accept('${dep}'`, `import.meta.hot.accept('${id}'`);
+        }
+        return source;
+    }
+    if (!supportedPaths.some((s) => resourcePath.includes(`/${s}/`)) &&
+        !supportedFileNames.some((s) => resourcePath.endsWith(s))) {
+        return source;
+    }
+    return `${source}
+  if (import.meta.hot && window.emberHotReloadPlugin) {
+      const result = window.emberHotReloadPlugin.canAcceptNew(import.meta.url);
+      result.then(() => {
+        if (!result) {
+          import.meta.hot.decline();
+        } else {
+          import.meta.hot.accept()
+        }
+      });
+  }
+  `;
+}
+function default_1(resolver) {
+    return {
+        name: 'hmr-plugin',
+        enforce: 'post',
+        transform(source, id) {
+            const options = {
+                resolver,
+                plugin: this,
+                source,
+                resourcePath: id,
+            };
+            return transform.call(options);
+        },
+    };
+}
+exports.default = default_1;

package/dist/services/webpack-hot-reload.js

@@ -0,0 +1,199 @@
+import Service, { service } from '@ember/service';
+import { getOwner } from '@ember/owner';
+import Router from '@ember/routing/route';
+import Controller from '@ember/controller';
+
+function _initializerDefineProperty(target, property, descriptor, context) {
+  if (!descriptor) return;
+  Object.defineProperty(target, property, {
+    enumerable: descriptor.enumerable,
+    configurable: descriptor.configurable,
+    writable: descriptor.writable,
+    value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
+  });
+}
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+  var desc = {};
+  Object.keys(descriptor).forEach(function (key) {
+    desc[key] = descriptor[key];
+  });
+  desc.enumerable = !!desc.enumerable;
+  desc.configurable = !!desc.configurable;
+  if ('value' in desc || desc.initializer) {
+    desc.writable = true;
+  }
+  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
+    return decorator(target, property, desc) || desc;
+  }, desc);
+  if (context && desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+    desc.initializer = undefined;
+  }
+  if (desc.initializer === void 0) {
+    Object.defineProperty(target, property, desc);
+    desc = null;
+  }
+  return desc;
+}
+
+var _dec, _class, _descriptor;
+const ChangeMap = new WeakMap();
+function getLatestChange(obj) {
+  while (ChangeMap.has(obj)) {
+    obj = ChangeMap.get(obj);
+  }
+  return obj;
+}
+let modulePrefix;
+let podModulePrefix;
+if (import.meta.hot) {
+  const ModuleMap = new Map();
+  window.emberHotReloadPlugin = {
+    _accepting: 0,
+    changed: {},
+    subscribers: [],
+    version: 1,
+    moduleDepCallbacks: {},
+    versionMap: {},
+    clear(module) {
+      this.moduleDepCallbacks[module.id] = {};
+    },
+    register(module, dep, callback) {
+      dep = dep.replace(new RegExp(`^${modulePrefix}/`), './');
+      this.moduleDepCallbacks[module.id][dep] = this.moduleDepCallbacks[module.id][dep] || [];
+      this.moduleDepCallbacks[module.id][dep].push(callback);
+    },
+    loadNew(oldModule, newModule) {
+      this.versionMap[newModule.id] = newModule.version;
+      const entry = Object.values(requirejs.entries).find(module => module.module.exports.default === oldModule.exports.default);
+      entry.module = {
+        exports: newModule.exports
+      };
+    },
+    __import(moduleUrl) {
+      return import( /* @vite-ignore */moduleUrl);
+    },
+    async canAcceptNew(moduleUrl) {
+      this._accepting += 1;
+      const m = await this.__import(moduleUrl);
+      const module = {
+        exports: m,
+        id: moduleUrl.split('?')[0]
+      };
+      this._accepting -= 1;
+      if (this._accepting === 0) {
+        setTimeout(() => this.notifyNew(), 0);
+      }
+      let ok = module.id.includes('/routes/') || module.id.includes('/routers/') || module.id.includes('/controllers/') || module.id.match(/controller\.(js|ts)$/) || module.id.match(/route\.(js|ts|gts)$/);
+      if (!ok) {
+        return false;
+      }
+      if (ModuleMap.get(module.id)) {
+        this.changed[module.id] = {
+          old: ModuleMap.get(module.id),
+          new: module
+        };
+      }
+      module.version = this.version;
+      ModuleMap.set(module.id, module);
+      return true;
+    },
+    notifyNew() {
+      this.version += 1;
+      Object.values(this.changed).forEach(change => {
+        this.loadNew(change.old, change.new);
+        this.subscribers.forEach(fn => fn(change.old, change.new));
+      });
+      this.changed = {};
+    },
+    subscribe(fn) {
+      this.subscribers.push(fn);
+    },
+    unsubscribe(fn) {
+      const idx = this.subscribers.indexOf(fn);
+      if (idx >= 0) {
+        this.subscribers.splice(idx, 1);
+      }
+    }
+  };
+}
+let WebpackHotReloadService = (_dec = service(), (_class = class WebpackHotReloadService extends Service {
+  constructor(...args) {
+    super(...args);
+    _initializerDefineProperty(this, "router", _descriptor, this);
+  }
+  init() {
+    super.init();
+    if (!window.emberHotReloadPlugin) return;
+    modulePrefix = getOwner(this).application.modulePrefix;
+    podModulePrefix = getOwner(this).application.podModulePrefix;
+    this.router._router;
+    Object.defineProperty(this.router._router, '_routerMicrolib', {
+      set(v) {
+        const getRoute = v.getRoute;
+        v.getRoute = function (name) {
+          return getRoute.call(this, `${name}--hot-version--${window.emberHotReloadPlugin.version}`);
+        };
+        this.___routerMicrolib = v;
+      },
+      get() {
+        return this.___routerMicrolib;
+      }
+    });
+    this.container = getOwner(this)?.__container__;
+    window.emberHotReloadPlugin.subscribe((oldModule, newModule) => {
+      const types = ['route', 'controller', 'template', 'modifier', 'helper', 'component'];
+      Object.keys(this.container.cache).forEach(k => {
+        if (types.some(t => k.startsWith(`${t}:`))) {
+          delete this.container.cache[k];
+        }
+      });
+      Object.keys(this.container.factoryManagerCache).forEach(k => {
+        if (types.some(t => k.startsWith(`${t}:`))) {
+          delete this.container.factoryManagerCache[k];
+        }
+      });
+      Object.keys(this.container.registry._resolveCache).forEach(k => {
+        if (types.some(t => k.startsWith(`${t}:`))) {
+          delete this.container.registry._resolveCache[k];
+        }
+      });
+      Object.keys(this.container.validationCache).forEach(k => {
+        if (types.some(t => k.startsWith(`${t}:`))) {
+          delete this.container.validationCache[k];
+        }
+      });
+      Object.keys(this.container.registry.registrations).forEach(k => {
+        if (types.some(t => k.startsWith(`${t}:`))) {
+          delete this.container.registry.registrations[k];
+        }
+      });
+      if (oldModule.exports.default?.prototype && oldModule.exports.default.prototype instanceof Router) {
+        this.router.refresh();
+      }
+      if (oldModule.exports.default?.prototype && oldModule.exports.default.prototype instanceof Controller) {
+        this.router.refresh();
+      }
+      if (oldModule.id.startsWith('./templates/') && !oldModule.id.startsWith('./templates/components/')) {
+        this.router.refresh();
+      }
+      if (oldModule.id.startsWith(`./${podModulePrefix}/`)) {
+        this.router.refresh();
+      }
+    });
+  }
+  getLatestChange(obj) {
+    return getLatestChange(obj);
+  }
+}, (_descriptor = _applyDecoratedDescriptor(_class.prototype, "router", [_dec], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+})), _class));
+// this service using `Owner.lookup('service:hot-reload')`, as well
+// as to check when you pass the service name as an argument to the decorator,
+// like `@service('hot-reload') declare altName: HotReloadService;`.
+
+export { WebpackHotReloadService as default };
+//# sourceMappingURL=webpack-hot-reload.js.map

package/dist/services/webpack-hot-reload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack-hot-reload.js","sources":["../../src/services/webpack-hot-reload.ts"],"sourcesContent":["import Service, { service } from '@ember/service';\nimport { getOwner } from '@ember/owner';\nimport RouterService from '@ember/routing/router-service';\nimport Router from '@ember/routing/route';\nimport Controller from '@ember/controller';\n\nconst ChangeMap = new WeakMap();\n\nfunction getLatestChange(obj) {\n  while (ChangeMap.has(obj)) {\n    obj = ChangeMap.get(obj);\n  }\n  return obj;\n}\n\nlet modulePrefix!: string;\nlet podModulePrefix!: string;\nif (import.meta.hot) {\n  const ModuleMap = new Map();\n\n  window.emberHotReloadPlugin = {\n    _accepting: 0,\n    changed: {},\n    subscribers: [],\n    version: 1,\n    moduleDepCallbacks: {},\n    versionMap: {},\n    clear(module) {\n      this.moduleDepCallbacks[module.id] = {};\n    },\n    register(module, dep, callback) {\n      dep = dep.replace(new RegExp(`^${modulePrefix}/`), './');\n      this.moduleDepCallbacks[module.id][dep] =\n        this.moduleDepCallbacks[module.id][dep] || [];\n      this.moduleDepCallbacks[module.id][dep].push(callback);\n    },\n    loadNew(oldModule, newModule) {\n      this.versionMap[newModule.id] = newModule.version;\n      const entry = Object.values(requirejs.entries).find(\n        (module) => module.module.exports.default === oldModule.exports.default,\n      );\n      entry.module = {\n        exports: newModule.exports,\n      };\n    },\n\n    __import(moduleUrl) {\n      return import(/* @vite-ignore */ moduleUrl);\n    },\n\n    async canAcceptNew(moduleUrl) {\n      this._accepting += 1;\n      const m = await this.__import(moduleUrl);\n      const module = {\n        exports: m,\n        id: moduleUrl.split('?')[0],\n      };\n      this._accepting -= 1;\n      if (this._accepting === 0) {\n        setTimeout(() => this.notifyNew(), 0);\n      }\n      let ok =\n        module.id.includes('/routes/') ||\n        module.id.includes('/routers/') ||\n        module.id.includes('/controllers/') ||\n        module.id.match(/controller\\.(js|ts)$/) ||\n        module.id.match(/route\\.(js|ts|gts)$/);\n      if (!ok) {\n        return false;\n      }\n\n      if (ModuleMap.get(module.id)) {\n        this.changed[module.id] = {\n          old: ModuleMap.get(module.id),\n          new: module,\n        };\n      }\n      module.version = this.version;\n      ModuleMap.set(module.id, module);\n      return true;\n    },\n    notifyNew() {\n      this.version += 1;\n      Object.values(this.changed).forEach((change) => {\n        this.loadNew(change.old, change.new);\n        this.subscribers.forEach((fn) => fn(change.old, change.new));\n      });\n      this.changed = {};\n    },\n    subscribe(fn) {\n      this.subscribers.push(fn);\n    },\n    unsubscribe(fn) {\n      const idx = this.subscribers.indexOf(fn);\n      if (idx >= 0) {\n        this.subscribers.splice(idx, 1);\n      }\n    },\n  };\n}\n\nexport default class WebpackHotReloadService extends Service {\n  declare container: any;\n  @service() router!: RouterService;\n\n  init() {\n    super.init();\n    if (!window.emberHotReloadPlugin) return;\n    modulePrefix = getOwner(this)!.application.modulePrefix;\n    podModulePrefix = getOwner(this)!.application.podModulePrefix;\n    this.router._router;\n    Object.defineProperty(this.router._router, '_routerMicrolib', {\n      set(v) {\n        const getRoute = v.getRoute;\n        v.getRoute = function (name) {\n          return getRoute.call(\n            this,\n            `${name}--hot-version--${window.emberHotReloadPlugin.version}`,\n          );\n        };\n        this.___routerMicrolib = v;\n      },\n      get() {\n        return this.___routerMicrolib;\n      },\n    });\n    this.container = getOwner(this)?.__container__;\n    window.emberHotReloadPlugin.subscribe((oldModule, newModule) => {\n      const types = [\n        'route',\n        'controller',\n        'template',\n        'modifier',\n        'helper',\n        'component',\n      ];\n      Object.keys(this.container.cache).forEach((k) => {\n        if (types.some((t) => k.startsWith(`${t}:`))) {\n          delete this.container.cache[k];\n        }\n      });\n      Object.keys(this.container.factoryManagerCache).forEach((k) => {\n        if (types.some((t) => k.startsWith(`${t}:`))) {\n          delete this.container.factoryManagerCache[k];\n        }\n      });\n      Object.keys(this.container.registry._resolveCache).forEach((k) => {\n        if (types.some((t) => k.startsWith(`${t}:`))) {\n          delete this.container.registry._resolveCache[k];\n        }\n      });\n      Object.keys(this.container.validationCache).forEach((k) => {\n        if (types.some((t) => k.startsWith(`${t}:`))) {\n          delete this.container.validationCache[k];\n        }\n      });\n      Object.keys(this.container.registry.registrations).forEach((k) => {\n        if (types.some((t) => k.startsWith(`${t}:`))) {\n          delete this.container.registry.registrations[k];\n        }\n      });\n      if (\n        oldModule.exports.default?.prototype &&\n        oldModule.exports.default.prototype instanceof Router\n      ) {\n        this.router.refresh();\n      }\n      if (\n        oldModule.exports.default?.prototype &&\n        oldModule.exports.default.prototype instanceof Controller\n      ) {\n        this.router.refresh();\n      }\n      if (\n        oldModule.id.startsWith('./templates/') &&\n        !oldModule.id.startsWith('./templates/components/')\n      ) {\n        this.router.refresh();\n      }\n      if (oldModule.id.startsWith(`./${podModulePrefix}/`)) {\n        this.router.refresh();\n      }\n    });\n  }\n  getLatestChange(obj) {\n    return getLatestChange(obj);\n  }\n}\n\n// Don't remove this declaration: this is what enables TypeScript to resolve\n// this service using `Owner.lookup('service:hot-reload')`, as well\n// as to check when you pass the service name as an argument to the decorator,\n// like `@service('hot-reload') declare altName: HotReloadService;`.\ndeclare module '@ember/service' {\n  interface Registry {\n    'hot-reload': WebpackHotReloadService;\n  }\n}\n"],"names":["ChangeMap","WeakMap","getLatestChange","obj","has","get","modulePrefix","podModulePrefix","import","meta","hot","ModuleMap","Map","window","emberHotReloadPlugin","_accepting","changed","subscribers","version","moduleDepCallbacks","versionMap","clear","module","id","register","dep","callback","replace","RegExp","push","loadNew","oldModule","newModule","entry","Object","values","requirejs","entries","find","exports","default","__import","moduleUrl","canAcceptNew","m","split","setTimeout","notifyNew","ok","includes","match","old","new","set","forEach","change","fn","subscribe","unsubscribe","idx","indexOf","splice","WebpackHotReloadService","_dec","service","_class","Service","constructor","args","_initializerDefineProperty","_descriptor","init","getOwner","application","router","_router","defineProperty","v","getRoute","name","call","___routerMicrolib","container","__container__","types","keys","cache","k","some","t","startsWith","factoryManagerCache","registry","_resolveCache","validationCache","registrations","prototype","Router","refresh","Controller","_applyDecoratedDescriptor","configurable","enumerable","writable","initializer"],"mappings":"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"}

package/dist/template-registry.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=template-registry.js.map

package/dist/template-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-registry.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,144 @@
+{
+  "name": "ember-vite-hmr",
+  "version": "0.1.0",
+  "keywords": [
+    "ember-addon"
+  ],
+  "private": false,
+  "description": "Builds EmberJS apps with Webpack Dev Server and Hot Reload",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/patricklx/ember-webpack-hot-reload"
+  },
+  "license": "MIT",
+  "author": "Patrick Pircher",
+  "main": "dist/lib/ember-webpack.js",
+  "files": [
+    "addon-main.cjs",
+    "dist"
+  ],
+  "scripts": {
+    "build": "concurrently 'pnpm:build:*'",
+    "build:js": "rollup --config",
+    "build:lib": "tsc --p tsconfig.lib.json",
+    "build:types": "glint --declaration",
+    "lint": "concurrently 'npm:lint:*(!fix)' --names 'lint:'",
+    "lint:fix": "concurrently 'npm:lint:*:fix' --names 'fix:'",
+    "lint:hbs": "ember-template-lint . --no-error-on-unmatched-pattern",
+    "lint:js": "eslint . --cache",
+    "lint:prettier": "prettier --check .",
+    "lint:hbs:fix": "ember-template-lint . --fix --no-error-on-unmatched-pattern",
+    "lint:js:fix": "eslint . --fix",
+    "lint:prettier:fix": "prettier --w .",
+    "lint:types": "glint",
+    "start": "concurrently 'npm:start:*'",
+    "start:js": "rollup --config --watch --no-watch.clearScreen",
+    "start:types": "glint --declaration --watch",
+    "test": "vitest",
+    "prepack": "pnpm build || echo 'its okay'"
+  },
+  "dependencies": {
+    "@glimmer/syntax": "^0.88.1",
+    "@babel/core": "^7.23.2",
+    "@babel/plugin-transform-typescript": "^7.22.15",
+    "@embroider/addon-shim": "^1.0.0",
+    "@embroider/babel-loader-9": "^3.1.0",
+    "@embroider/hbs-loader": "^3.0.2",
+    "@embroider/shared-internals": "^2.5.0",
+    "@types/supports-color": "^8.1.0",
+    "assert-never": "^1.2.1",
+    "babel-loader": "^8.2.2",
+    "babel-preset-env": "^1.7.0",
+    "css-loader": "^5.2.6",
+    "csso": "^4.2.0",
+    "debug": "^4.3.4",
+    "escape-string-regexp": "^4.0.0",
+    "fs-extra": "^9.1.0",
+    "html-webpack-plugin": "^5.5.3",
+    "vite": "^5.0.12",
+    "vitest": "^1.2.2",
+    "jsdom": "^16.6.0",
+    "lodash": "^4.17.21",
+    "mini-css-extract-plugin": "^2.5.3",
+    "semver": "^7.3.5",
+    "source-map-url": "^0.4.1",
+    "style-loader": "^2.0.0",
+    "supports-color": "^8.1.0",
+    "terser": "^5.7.0",
+    "thread-loader": "^3.0.4",
+    "webpack-dev-server": "^4.15.1"
+  },
+  "devDependencies": {
+    "@babel/eslint-parser": "^7.19.1",
+    "@babel/plugin-proposal-class-properties": "^7.16.7",
+    "@babel/plugin-proposal-decorators": "^7.20.13",
+    "@babel/plugin-transform-class-static-block": "^7.20.0",
+    "@babel/runtime": "^7.17.0",
+    "@embroider/addon-dev": "^4.1.0",
+    "@embroider/core": "^3.3.0",
+    "@glint/core": "^1.2.0",
+    "@glint/environment-ember-loose": "^1.2.0",
+    "@glint/environment-ember-template-imports": "^1.2.0",
+    "@glint/template": "^1.2.0",
+    "@rollup/plugin-babel": "^6.0.3",
+    "@tsconfig/ember": "^2.0.0",
+    "@types/babel__core": "^7.20.3",
+    "@types/babel__traverse": "^7.20.3",
+    "@types/csso": "^3.5.1",
+    "@types/debug": "^4.1.5",
+    "@types/fs-extra": "^9.0.12",
+    "@types/lodash": "^4.14.170",
+    "@types/mini-css-extract-plugin": "^1.4.3",
+    "@types/node": "^15.12.2",
+    "@types/semver": "^7.3.6",
+    "babel-plugin-ember-template-compilation": "^2.2.0",
+    "concurrently": "^8.0.1",
+    "ember-resolver": "^11.0.1",
+    "ember-source": "^5.3.0",
+    "ember-template-lint": "^5.11.2",
+    "eslint": "^8.33.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-ember": "^11.11.1",
+    "eslint-plugin-n": "^16.0.0",
+    "eslint-plugin-prettier": "^5.0.0",
+    "prettier": "^3.0.3",
+    "prettier-plugin-ember-template-tag": "^1.1.0",
+    "rollup": "^3.21.8",
+    "typescript": "^5.1.6"
+  },
+  "peerDependencies": {
+    "@embroider/compat": "^3.3.0"
+  },
+  "engines": {
+    "node": "12.* || 14.* || >= 16"
+  },
+  "ember": {
+    "edition": "octane"
+  },
+  "ember-addon": {
+    "version": 2,
+    "type": "addon",
+    "main": "addon-main.cjs",
+    "app-js": {
+      "./initializers/webpack-hot-reload.js": "./dist/_app_/initializers/webpack-hot-reload.js",
+      "./services/webpack-hot-reload.js": "./dist/_app_/services/webpack-hot-reload.js"
+    }
+  },
+  "exports": {
+    ".": {
+      "default": "./dist/lib/ember-webpack.js"
+    },
+    "./*": {
+      "types": "./declarations/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./addon-main.js": "./addon-main.cjs"
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "declarations/*"
+      ]
+    }
+  }
+}