@embroider/core 2.0.1 → 2.1.0

package/src/babel-plugin-stage1-inline-hbs.js

@@ -0,0 +1,96 @@
+"use strict";
+/*
+  This babel plugins is responsible for running custom AST transform in inline
+  templates. It doesn't compile to wire format, because it runs at stage1.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const shared_internals_1 = require("@embroider/shared-internals");
+function make(getCompiler) {
+    function stage1InlineHBSTransform(babel) {
+        let t = babel.types;
+        return {
+            visitor: {
+                TaggedTemplateExpression(path, state) {
+                    for (let { module, exportedName } of shared_internals_1.templateCompilationModules) {
+                        if (path.get('tag').referencesImport(module, exportedName)) {
+                            handleTagged(path, state, t);
+                        }
+                    }
+                },
+                CallExpression(path, state) {
+                    for (let { module, exportedName } of shared_internals_1.templateCompilationModules) {
+                        if (path.get('callee').referencesImport(module, exportedName)) {
+                            handleCalled(path, state, t);
+                        }
+                    }
+                },
+            },
+        };
+    }
+    stage1InlineHBSTransform._parallelBabel = {
+        requireFile: __filename,
+    };
+    stage1InlineHBSTransform.baseDir = function () {
+        return (0, path_1.join)(__dirname, '..');
+    };
+    function handleTagged(path, state, t) {
+        if (path.node.quasi.expressions.length) {
+            throw path.buildCodeFrameError('placeholders inside a tagged template string are not supported');
+        }
+        let template = path.node.quasi.quasis.map(quasi => quasi.value.cooked).join('');
+        let compiled = compiler(state).applyTransforms(state.file.opts.filename, template);
+        path.get('quasi').replaceWith(t.templateLiteral([t.templateElement({ raw: compiled, cooked: compiled })], []));
+    }
+    function handleCalled(path, state, t) {
+        let { template, insertRuntimeErrors } = getCallArguments(path);
+        let compilerInstance = compiler(state);
+        let compiled;
+        try {
+            compiled = compilerInstance.applyTransforms(state.file.opts.filename, template);
+        }
+        catch (err) {
+            if (insertRuntimeErrors) {
+                // in stage 1 we just leave the bad template in place (we were only
+                // trying to run transforms and re-emit hbs), so that it will be handled
+                // at stage3 instead.
+                return;
+            }
+            throw err;
+        }
+        path.get('arguments')[0].replaceWith(t.stringLiteral(compiled));
+    }
+    function compiler(state) {
+        if (!state.templateCompiler) {
+            state.templateCompiler = getCompiler(state.opts);
+        }
+        return state.templateCompiler;
+    }
+    function getCallArguments(path) {
+        let [template, options] = path.node.arguments;
+        let insertRuntimeErrors = (options === null || options === void 0 ? void 0 : options.type) === 'ObjectExpression' &&
+            options.properties.some(prop => prop.type === 'ObjectProperty' &&
+                prop.computed === false &&
+                prop.key.type === 'Identifier' &&
+                prop.key.name === 'insertRuntimeErrors' &&
+                prop.value.type === 'BooleanLiteral' &&
+                prop.value.value);
+        return {
+            template: getTemplateString(template, path),
+            insertRuntimeErrors,
+        };
+    }
+    return stage1InlineHBSTransform;
+}
+exports.default = make;
+function getTemplateString(template, path) {
+    if ((template === null || template === void 0 ? void 0 : template.type) === 'StringLiteral') {
+        return template.value;
+    }
+    // treat inert TemplateLiteral (without subexpressions) like a StringLiteral
+    if ((template === null || template === void 0 ? void 0 : template.type) === 'TemplateLiteral' && !template.expressions.length) {
+        return template.quasis[0].value.cooked;
+    }
+    throw path.buildCodeFrameError('hbs accepts only a string literal argument');
+}
+//# sourceMappingURL=babel-plugin-stage1-inline-hbs.js.map

package/src/babel-plugin-stage1-inline-hbs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-stage1-inline-hbs.js","sourceRoot":"","sources":["babel-plugin-stage1-inline-hbs.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  This babel plugins is responsible for running custom AST transform in inline\n  templates. It doesn't compile to wire format, because it runs at stage1.\n*/\n\nimport { join } from 'path';\nimport type { TemplateCompiler } from './template-compiler-common';\nimport type { NodePath } from '@babel/traverse';\nimport type * as Babel from '@babel/core';\nimport type { types as t } from '@babel/core';\nimport { templateCompilationModules } from '@embroider/shared-internals';\n\nexport default function make<Opts>(getCompiler: (opts: Opts) => TemplateCompiler) {\n  interface State {\n    opts: Opts;\n    file: {\n      code: string;\n      opts: {\n        filename: string;\n      };\n    };\n    templateCompiler: TemplateCompiler | undefined;\n  }\n\n  function stage1InlineHBSTransform(babel: typeof Babel): unknown {\n    let t = babel.types;\n    return {\n      visitor: {\n        TaggedTemplateExpression(path: NodePath<t.TaggedTemplateExpression>, state: State) {\n          for (let { module, exportedName } of templateCompilationModules) {\n            if (path.get('tag').referencesImport(module, exportedName)) {\n              handleTagged(path, state, t);\n            }\n          }\n        },\n        CallExpression(path: NodePath<t.CallExpression>, state: State) {\n          for (let { module, exportedName } of templateCompilationModules) {\n            if (path.get('callee').referencesImport(module, exportedName)) {\n              handleCalled(path, state, t);\n            }\n          }\n        },\n      },\n    };\n  }\n\n  stage1InlineHBSTransform._parallelBabel = {\n    requireFile: __filename,\n  };\n\n  stage1InlineHBSTransform.baseDir = function () {\n    return join(__dirname, '..');\n  };\n\n  function handleTagged(path: NodePath<t.TaggedTemplateExpression>, state: State, t: typeof Babel.types) {\n    if (path.node.quasi.expressions.length) {\n      throw path.buildCodeFrameError('placeholders inside a tagged template string are not supported');\n    }\n    let template = path.node.quasi.quasis.map(quasi => quasi.value.cooked).join('');\n    let compiled = compiler(state).applyTransforms(state.file.opts.filename, template);\n    path.get('quasi').replaceWith(t.templateLiteral([t.templateElement({ raw: compiled, cooked: compiled })], []));\n  }\n\n  function handleCalled(path: NodePath<t.CallExpression>, state: State, t: typeof Babel.types) {\n    let { template, insertRuntimeErrors } = getCallArguments(path);\n    let compilerInstance = compiler(state);\n\n    let compiled: string;\n    try {\n      compiled = compilerInstance.applyTransforms(state.file.opts.filename, template);\n    } catch (err) {\n      if (insertRuntimeErrors) {\n        // in stage 1 we just leave the bad template in place (we were only\n        // trying to run transforms and re-emit hbs), so that it will be handled\n        // at stage3 instead.\n        return;\n      }\n      throw err;\n    }\n    (path.get('arguments')[0] as NodePath).replaceWith(t.stringLiteral(compiled));\n  }\n\n  function compiler(state: State) {\n    if (!state.templateCompiler) {\n      state.templateCompiler = getCompiler(state.opts);\n    }\n    return state.templateCompiler;\n  }\n\n  function getCallArguments(path: NodePath<t.CallExpression>): { template: string; insertRuntimeErrors: boolean } {\n    let [template, options] = path.node.arguments;\n\n    let insertRuntimeErrors =\n      options?.type === 'ObjectExpression' &&\n      options.properties.some(\n        prop =>\n          prop.type === 'ObjectProperty' &&\n          prop.computed === false &&\n          prop.key.type === 'Identifier' &&\n          prop.key.name === 'insertRuntimeErrors' &&\n          prop.value.type === 'BooleanLiteral' &&\n          prop.value.value\n      );\n\n    return {\n      template: getTemplateString(template, path),\n      insertRuntimeErrors,\n    };\n  }\n\n  return stage1InlineHBSTransform;\n}\n\nfunction getTemplateString(template: any, path: NodePath<t.CallExpression>): string {\n  if (template?.type === 'StringLiteral') {\n    return template.value;\n  }\n  // treat inert TemplateLiteral (without subexpressions) like a StringLiteral\n  if (template?.type === 'TemplateLiteral' && !template.expressions.length) {\n    return template.quasis[0].value.cooked;\n  }\n  throw path.buildCodeFrameError('hbs accepts only a string literal argument');\n}\n"]}

package/src/browser-index.d.ts

@@ -0,0 +1 @@
+export { TemplateCompiler, TemplateCompilerParams } from './template-compiler-common';

package/src/browser-index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateCompiler = void 0;
+var template_compiler_common_1 = require("./template-compiler-common");
+Object.defineProperty(exports, "TemplateCompiler", { enumerable: true, get: function () { return template_compiler_common_1.TemplateCompiler; } });
+//# sourceMappingURL=browser-index.js.map

package/src/browser-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-index.js","sourceRoot":"","sources":["browser-index.ts"],"names":[],"mappings":";;;AAAA,uEAAsF;AAA7E,4HAAA,gBAAgB,OAAA","sourcesContent":["export { TemplateCompiler, TemplateCompilerParams } from './template-compiler-common';\n"]}

package/src/ember-template-compiler-types.d.ts

@@ -0,0 +1,41 @@
+export interface Plugins {
+    ast?: unknown[];
+}
+export interface AST {
+    _deliberatelyOpaque: 'AST';
+}
+export interface PreprocessOptions {
+    contents: string;
+    moduleName: string;
+    plugins?: Plugins;
+    filename?: string;
+    parseOptions?: {
+        srcName?: string;
+        ignoreStandalone?: boolean;
+    };
+    mode?: 'codemod' | 'precompile';
+    strictMode?: boolean;
+    locals?: string[];
+}
+export interface PrinterOptions {
+    entityEncoding?: 'transformed' | 'raw';
+}
+export interface GlimmerSyntax {
+    preprocess(html: string, options?: PreprocessOptions): AST;
+    print(ast: AST, options?: PrinterOptions): string;
+    defaultOptions(options: PreprocessOptions): PreprocessOptions;
+    precompile(templateContents: string, options: {
+        contents: string;
+        moduleName: string;
+        filename: string;
+        plugins?: any;
+        parseOptions?: {
+            srcName?: string;
+        };
+    }): string;
+    _Ember: {
+        FEATURES: any;
+        ENV: any;
+    };
+    cacheKey: string;
+}

package/src/ember-template-compiler-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ember-template-compiler-types.js.map

package/src/ember-template-compiler-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ember-template-compiler-types.js","sourceRoot":"","sources":["ember-template-compiler-types.ts"],"names":[],"mappings":"","sourcesContent":["export interface Plugins {\n  ast?: unknown[];\n}\n\nexport interface AST {\n  _deliberatelyOpaque: 'AST';\n}\n\nexport interface PreprocessOptions {\n  contents: string;\n  moduleName: string;\n  plugins?: Plugins;\n  filename?: string;\n\n  parseOptions?: {\n    srcName?: string;\n    ignoreStandalone?: boolean;\n  };\n\n  // added in Ember 3.17 (@glimmer/syntax@0.40.2)\n  mode?: 'codemod' | 'precompile';\n\n  // added in Ember 3.25\n  strictMode?: boolean;\n  locals?: string[];\n}\n\nexport interface PrinterOptions {\n  entityEncoding?: 'transformed' | 'raw';\n}\n\n// This just reflects the API we're extracting from ember-template-compiler.js,\n// plus a cache key that lets us know when the underlying source has remained\n// stable.\nexport interface GlimmerSyntax {\n  preprocess(html: string, options?: PreprocessOptions): AST;\n  print(ast: AST, options?: PrinterOptions): string;\n  defaultOptions(options: PreprocessOptions): PreprocessOptions;\n  precompile(\n    templateContents: string,\n    options: {\n      contents: string;\n      moduleName: string;\n      filename: string;\n      plugins?: any;\n      parseOptions?: {\n        srcName?: string;\n      };\n    }\n  ): string;\n  _Ember: { FEATURES: any; ENV: any };\n  cacheKey: string;\n}\n"]}

package/src/load-ember-template-compiler.d.ts

@@ -0,0 +1,6 @@
+declare type EmbersExports = {
+    cacheKey: string;
+    theExports: any;
+};
+export declare function getEmberExports(templateCompilerPath: string): EmbersExports;
+export {};

package/src/load-ember-template-compiler.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEmberExports = void 0;
+const fs_1 = require("fs");
+const vm_1 = require("vm");
+const crypto_1 = require("crypto");
+const patch_template_compiler_1 = require("./patch-template-compiler");
+const CACHE = new Map();
+function getEmberExports(templateCompilerPath) {
+    let entry = CACHE.get(templateCompilerPath);
+    if (entry) {
+        let currentStat = (0, fs_1.statSync)(templateCompilerPath);
+        // Let's ensure the template is still what we cached
+        if (currentStat.mode === entry.stat.mode &&
+            currentStat.size === entry.stat.size &&
+            currentStat.mtime.getTime() === entry.stat.mtime.getTime()) {
+            return entry.value;
+        }
+    }
+    let stat = (0, fs_1.statSync)(templateCompilerPath);
+    let source = (0, patch_template_compiler_1.patch)((0, fs_1.readFileSync)(templateCompilerPath, 'utf8'), templateCompilerPath);
+    let theExports = undefined;
+    // cacheKey, theExports
+    let cacheKey = (0, crypto_1.createHash)('md5').update(source).digest('hex');
+    entry = Object.freeze({
+        value: {
+            cacheKey,
+            get theExports() {
+                if (theExports) {
+                    return theExports;
+                }
+                // matches (essentially) what ember-cli-htmlbars does in https://git.io/Jtbpj
+                let sandbox = {
+                    module: { require, exports: {} },
+                    require,
+                };
+                if (typeof globalThis === 'undefined') {
+                    // for Node 10 usage with Ember 3.27+ we have to define the `global` global
+                    // in order for ember-template-compiler.js to evaluate properly
+                    // due to this code https://git.io/Jtb7
+                    sandbox.global = sandbox;
+                }
+                // using vm.createContext / vm.Script to ensure we evaluate in a fresh sandbox context
+                // so that any global mutation done within ember-template-compiler.js does not leak out
+                let context = (0, vm_1.createContext)(sandbox);
+                let script = new vm_1.Script(source, { filename: templateCompilerPath });
+                script.runInContext(context);
+                return (theExports = context.module.exports);
+            },
+        },
+        stat, // This is stored, so we can reload the templateCompiler if it changes mid-build.
+    });
+    CACHE.set(templateCompilerPath, entry);
+    return entry.value;
+}
+exports.getEmberExports = getEmberExports;
+//# sourceMappingURL=load-ember-template-compiler.js.map

package/src/load-ember-template-compiler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-ember-template-compiler.js","sourceRoot":"","sources":["load-ember-template-compiler.ts"],"names":[],"mappings":";;;AAAA,2BAAgD;AAChD,2BAA2C;AAC3C,mCAAoC;AACpC,uEAAkD;AAYlD,MAAM,KAAK,GAAG,IAAI,GAAG,EAAsC,CAAC;AAE5D,SAAgB,eAAe,CAAC,oBAA4B;IAC1D,IAAI,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;IAE5C,IAAI,KAAK,EAAE;QACT,IAAI,WAAW,GAAG,IAAA,aAAQ,EAAC,oBAAoB,CAAC,CAAC;QAEjD,oDAAoD;QACpD,IACE,WAAW,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,IAAI;YACpC,WAAW,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,IAAI;YACpC,WAAW,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,EAC1D;YACA,OAAO,KAAK,CAAC,KAAK,CAAC;SACpB;KACF;IAED,IAAI,IAAI,GAAG,IAAA,aAAQ,EAAC,oBAAoB,CAAC,CAAC;IAE1C,IAAI,MAAM,GAAG,IAAA,+BAAK,EAAC,IAAA,iBAAY,EAAC,oBAAoB,EAAE,MAAM,CAAC,EAAE,oBAAoB,CAAC,CAAC;IACrF,IAAI,UAAU,GAAQ,SAAS,CAAC;IAEhC,uBAAuB;IACvB,IAAI,QAAQ,GAAG,IAAA,mBAAU,EAAC,KAAK,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAE9D,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC;QACpB,KAAK,EAAE;YACL,QAAQ;YACR,IAAI,UAAU;gBACZ,IAAI,UAAU,EAAE;oBACd,OAAO,UAAU,CAAC;iBACnB;gBAED,6EAA6E;gBAC7E,IAAI,OAAO,GAAG;oBACZ,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE;oBAChC,OAAO;iBACR,CAAC;gBAEF,IAAI,OAAO,UAAU,KAAK,WAAW,EAAE;oBACrC,2EAA2E;oBAC3E,+DAA+D;oBAC/D,uCAAuC;oBACtC,OAAe,CAAC,MAAM,GAAG,OAAO,CAAC;iBACnC;gBACD,sFAAsF;gBACtF,uFAAuF;gBACvF,IAAI,OAAO,GAAG,IAAA,kBAAa,EAAC,OAAO,CAAC,CAAC;gBACrC,IAAI,MAAM,GAAG,IAAI,WAAM,CAAC,MAAM,EAAE,EAAE,QAAQ,EAAE,oBAAoB,EAAE,CAAC,CAAC;gBAEpE,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;gBAC7B,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAC/C,CAAC;SACF;QACD,IAAI,EAAE,iFAAiF;KACxF,CAAC,CAAC;IAEH,KAAK,CAAC,GAAG,CAAC,oBAAoB,EAAE,KAAK,CAAC,CAAC;IACvC,OAAO,KAAK,CAAC,KAAK,CAAC;AACrB,CAAC;AA1DD,0CA0DC","sourcesContent":["import fs, { readFileSync, statSync } from 'fs';\nimport { createContext, Script } from 'vm';\nimport { createHash } from 'crypto';\nimport { patch } from './patch-template-compiler';\n\ntype TemplateCompilerCacheEntry = {\n  value: EmbersExports;\n  stat: fs.Stats;\n};\n\ntype EmbersExports = {\n  cacheKey: string;\n  theExports: any;\n};\n\nconst CACHE = new Map<string, TemplateCompilerCacheEntry>();\n\nexport function getEmberExports(templateCompilerPath: string): EmbersExports {\n  let entry = CACHE.get(templateCompilerPath);\n\n  if (entry) {\n    let currentStat = statSync(templateCompilerPath);\n\n    // Let's ensure the template is still what we cached\n    if (\n      currentStat.mode === entry.stat.mode &&\n      currentStat.size === entry.stat.size &&\n      currentStat.mtime.getTime() === entry.stat.mtime.getTime()\n    ) {\n      return entry.value;\n    }\n  }\n\n  let stat = statSync(templateCompilerPath);\n\n  let source = patch(readFileSync(templateCompilerPath, 'utf8'), templateCompilerPath);\n  let theExports: any = undefined;\n\n  // cacheKey, theExports\n  let cacheKey = createHash('md5').update(source).digest('hex');\n\n  entry = Object.freeze({\n    value: {\n      cacheKey,\n      get theExports() {\n        if (theExports) {\n          return theExports;\n        }\n\n        // matches (essentially) what ember-cli-htmlbars does in https://git.io/Jtbpj\n        let sandbox = {\n          module: { require, exports: {} },\n          require,\n        };\n\n        if (typeof globalThis === 'undefined') {\n          // for Node 10 usage with Ember 3.27+ we have to define the `global` global\n          // in order for ember-template-compiler.js to evaluate properly\n          // due to this code https://git.io/Jtb7\n          (sandbox as any).global = sandbox;\n        }\n        // using vm.createContext / vm.Script to ensure we evaluate in a fresh sandbox context\n        // so that any global mutation done within ember-template-compiler.js does not leak out\n        let context = createContext(sandbox);\n        let script = new Script(source, { filename: templateCompilerPath });\n\n        script.runInContext(context);\n        return (theExports = context.module.exports);\n      },\n    },\n    stat, // This is stored, so we can reload the templateCompiler if it changes mid-build.\n  });\n\n  CACHE.set(templateCompilerPath, entry);\n  return entry.value;\n}\n"]}

package/src/messages.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="qunit" />
-/// <reference types="ember-qunit" />
 import makeDebug from 'debug';
 declare const todo: makeDebug.Debugger;
 declare const unsupported: makeDebug.Debugger;

package/src/mini-modules-polyfill.d.ts

@@ -0,0 +1,12 @@
+import type { types as t } from '@babel/core';
+import type { NodePath } from '@babel/traverse';
+declare type BabelTypes = typeof t;
+export default function miniModulesPolyfill(babel: unknown): {
+    visitor: {
+        Program: {
+            exit(path: NodePath<t.Program>): void;
+        };
+    };
+};
+export declare function handleImportDeclaration(t: BabelTypes, path: NodePath<t.ImportDeclaration>): undefined;
+export {};

package/src/mini-modules-polyfill.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleImportDeclaration = void 0;
+// this is intentionally not the whole babel-plugin-ember-modules-api-polyfill.
+// That runs very early, so any usage of polyfilled imports that gets emitted by
+// our other babel plugins can't take advantage of it.
+//
+// If I was going to try to do this properly, I would change
+// babel-plugin-ember-modules-api-polyfill to run very late in the game, like
+// this code does, so that other plugins could always not worry about it. But
+// seeing as modules-api-polyfill is already on the way out, it's simpler to
+// just handle the small piece of its functionality that matter to us:
+//
+// - all our usage (emitted by our babel plugins) is static imports, not dynamic
+//   ones, so it's OK to just walk the top level, saving us the cost of a full
+//   traverse
+// - we only emit a handful of specific imports that are easy to just list here
+//
+//
+let replacements = {
+    '@ember/component/template-only': {
+        default(t) {
+            return t.memberExpression(t.identifier('Ember'), t.identifier('_templateOnlyComponent'));
+        },
+    },
+    '@ember/template-factory': {
+        createTemplateFactory(t) {
+            return t.memberExpression(t.memberExpression(t.identifier('Ember'), t.identifier('HTMLBars')), t.identifier('template'));
+        },
+    },
+    '@ember/component': {
+        default(t) {
+            return t.memberExpression(t.identifier('Ember'), t.identifier('Component'));
+        },
+        setComponentTemplate(t) {
+            return t.memberExpression(t.identifier('Ember'), t.identifier('_setComponentTemplate'));
+        },
+    },
+};
+function miniModulesPolyfill(babel) {
+    let t = babel.types;
+    return {
+        visitor: {
+            Program: {
+                exit(path) {
+                    for (let child of path.get('body')) {
+                        if (child.isImportDeclaration()) {
+                            let replacement = handleImportDeclaration(t, child);
+                            if (replacement) {
+                                path.replaceWith(replacement);
+                            }
+                        }
+                    }
+                },
+            },
+        },
+    };
+}
+exports.default = miniModulesPolyfill;
+function handleImportDeclaration(t, path) {
+    let match = replacements[path.node.source.value];
+    if (match) {
+        let specifiers = path.get('specifiers');
+        let replacers = specifiers.map(specifier => ({ replacer: match[specifier.node.local.name], specifier }));
+        if (replacers.every(r => Boolean(r.replacer))) {
+            path.replaceWith(t.variableDeclaration('const', replacers.map(r => t.variableDeclarator(r.specifier.node.local, r.replacer(t)))));
+        }
+        else {
+            for (let { specifier, replacer } of replacers) {
+                if (replacer) {
+                    path.insertAfter(t.variableDeclaration('const', [t.variableDeclarator(specifier.node.local, replacer(t))]));
+                    specifier.remove();
+                }
+            }
+        }
+    }
+    return undefined;
+}
+exports.handleImportDeclaration = handleImportDeclaration;
+//# sourceMappingURL=mini-modules-polyfill.js.map

package/src/mini-modules-polyfill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mini-modules-polyfill.js","sourceRoot":"","sources":["mini-modules-polyfill.ts"],"names":[],"mappings":"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","sourcesContent":["import type { types as t } from '@babel/core';\nimport type { NodePath } from '@babel/traverse';\n\ntype BabelTypes = typeof t;\n\n// this is intentionally not the whole babel-plugin-ember-modules-api-polyfill.\n// That runs very early, so any usage of polyfilled imports that gets emitted by\n// our other babel plugins can't take advantage of it.\n//\n// If I was going to try to do this properly, I would change\n// babel-plugin-ember-modules-api-polyfill to run very late in the game, like\n// this code does, so that other plugins could always not worry about it. But\n// seeing as modules-api-polyfill is already on the way out, it's simpler to\n// just handle the small piece of its functionality that matter to us:\n//\n// - all our usage (emitted by our babel plugins) is static imports, not dynamic\n//   ones, so it's OK to just walk the top level, saving us the cost of a full\n//   traverse\n// - we only emit a handful of specific imports that are easy to just list here\n//\n//\nlet replacements: { [moduleSpecifier: string]: { [name: string]: ((t: BabelTypes) => t.Expression) | undefined } } = {\n  '@ember/component/template-only': {\n    default(t: BabelTypes) {\n      return t.memberExpression(t.identifier('Ember'), t.identifier('_templateOnlyComponent'));\n    },\n  },\n  '@ember/template-factory': {\n    createTemplateFactory(t) {\n      return t.memberExpression(\n        t.memberExpression(t.identifier('Ember'), t.identifier('HTMLBars')),\n        t.identifier('template')\n      );\n    },\n  },\n  '@ember/component': {\n    default(t: BabelTypes) {\n      return t.memberExpression(t.identifier('Ember'), t.identifier('Component'));\n    },\n    setComponentTemplate(t: BabelTypes) {\n      return t.memberExpression(t.identifier('Ember'), t.identifier('_setComponentTemplate'));\n    },\n  },\n};\n\nexport default function miniModulesPolyfill(babel: unknown) {\n  let t = (babel as any).types as BabelTypes;\n  return {\n    visitor: {\n      Program: {\n        exit(path: NodePath<t.Program>) {\n          for (let child of path.get('body')) {\n            if (child.isImportDeclaration()) {\n              let replacement = handleImportDeclaration(t, child);\n              if (replacement) {\n                path.replaceWith(replacement);\n              }\n            }\n          }\n        },\n      },\n    },\n  };\n}\n\nexport function handleImportDeclaration(t: BabelTypes, path: NodePath<t.ImportDeclaration>) {\n  let match = replacements[path.node.source.value];\n  if (match) {\n    let specifiers = path.get('specifiers');\n    let replacers = specifiers.map(specifier => ({ replacer: match[specifier.node.local.name], specifier }));\n    if (replacers.every(r => Boolean(r.replacer))) {\n      path.replaceWith(\n        t.variableDeclaration(\n          'const',\n          replacers.map(r => t.variableDeclarator(r.specifier.node.local, r.replacer!(t)))\n        )\n      );\n    } else {\n      for (let { specifier, replacer } of replacers) {\n        if (replacer) {\n          path.insertAfter(t.variableDeclaration('const', [t.variableDeclarator(specifier.node.local, replacer(t))]));\n          specifier.remove();\n        }\n      }\n    }\n  }\n  return undefined;\n}\n"]}

package/src/module-resolver.d.ts

@@ -0,0 +1,46 @@
+import { Package } from '@embroider/shared-internals';
+export interface Options {
+    renamePackages: {
+        [fromName: string]: string;
+    };
+    renameModules: {
+        [fromName: string]: string;
+    };
+    extraImports: {
+        absPath: string;
+        target: string;
+        runtimeName?: string;
+    }[];
+    externalsDir: string;
+    activeAddons: {
+        [packageName: string]: string;
+    };
+    relocatedFiles: {
+        [relativePath: string]: string;
+    };
+    resolvableExtensions: string[];
+    appRoot: string;
+}
+export declare type Resolution = {
+    result: 'continue';
+} | {
+    result: 'redirect-to';
+    specifier: string;
+} | {
+    result: 'external';
+    specifier: string;
+} | {
+    result: 'runtime-failure';
+    specifier: string;
+};
+export declare class Resolver {
+    readonly filename: string;
+    private options;
+    readonly originalFilename: string;
+    constructor(filename: string, options: Options);
+    resolve(specifier: string, isDynamic: boolean): Resolution;
+    owningPackage(): Package | undefined;
+    private relocatedIntoPackage;
+    private handleRenaming;
+    private handleExternal;
+}