@embroider/core 3.5.1-unstable.fc482ba → 3.5.2

package/src/node-resolve.js

@@ -1,130 +1,62 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeRequestAdapter = void 0;
-exports.nodeResolve = nodeResolve;
-const virtual_content_1 = require("./virtual-content");
+exports.resolve = resolve;
 const path_1 = require("path");
 const shared_internals_1 = require("@embroider/shared-internals");
-const assert_never_1 = __importDefault(require("assert-never"));
-// these would be circular, but they're type-only so it's fine
-const module_request_1 = require("./module-request");
-class NodeRequestAdapter {
-    constructor(resolver, extensions) {
-        this.resolver = resolver;
-        this.extensions = extensions;
-    }
-    get debugType() {
-        return 'node';
-    }
-    notFoundResponse(request) {
-        let err = new Error(`module not found ${request.specifier}`);
-        err.code = 'MODULE_NOT_FOUND';
-        return {
-            type: 'not_found',
-            err,
-        };
-    }
-    virtualResponse(_request, virtual) {
-        return {
-            type: 'found',
-            filename: virtual.specifier,
-            virtual,
-            result: {
-                type: 'virtual',
-                content: (0, virtual_content_1.virtualContent)(virtual, this.resolver).src,
-                filename: virtual.specifier,
-            },
-        };
+function resolve(specifier, fromFile, extensions = ['.hbs.js', '.hbs']) {
+    // require.resolve does not like when we resolve from virtual paths.
+    // That is, a request like "../thing.js" from
+    // "/a/real/path/VIRTUAL_SUBDIR/virtual.js" has an unambiguous target of
+    // "/a/real/path/thing.js", but require.resolve won't do that path
+    // adjustment until after checking whether VIRTUAL_SUBDIR actually
+    // exists.
+    //
+    // We can do the path adjustments before doing require.resolve.
+    let fromDir = (0, path_1.dirname)(fromFile);
+    if (!(0, path_1.isAbsolute)(specifier) && specifier.startsWith('.')) {
+        let targetPath = (0, path_1.resolve)(fromDir, specifier);
+        let newFromDir = (0, path_1.dirname)(targetPath);
+        if (fromDir !== newFromDir) {
+            specifier = (0, shared_internals_1.explicitRelative)(newFromDir, targetPath);
+            fromDir = newFromDir;
+        }
     }
-    async resolve(request) {
-        // require.resolve does not like when we resolve from virtual paths.
-        // That is, a request like "../thing.js" from
-        // "/a/real/path/VIRTUAL_SUBDIR/virtual.js" has an unambiguous target of
-        // "/a/real/path/thing.js", but require.resolve won't do that path
-        // adjustment until after checking whether VIRTUAL_SUBDIR actually
-        // exists.
-        //
-        // We can do the path adjustments before doing require.resolve.
-        let { specifier } = request;
-        let fromDir = (0, path_1.dirname)(request.fromFile);
-        if (!(0, path_1.isAbsolute)(specifier) && specifier.startsWith('.')) {
-            let targetPath = (0, path_1.resolve)(fromDir, specifier);
-            let newFromDir = (0, path_1.dirname)(targetPath);
-            if (fromDir !== newFromDir) {
-                specifier = (0, shared_internals_1.explicitRelative)(newFromDir, targetPath);
-                fromDir = newFromDir;
-            }
+    let initialError;
+    for (let candidate of candidates(specifier, extensions)) {
+        let filename;
+        try {
+            filename = require.resolve(candidate, {
+                paths: [fromDir],
+            });
         }
-        let initialError;
-        for (let candidate of candidates(specifier, this.extensions)) {
-            let filename;
-            try {
-                filename = require.resolve(candidate, {
-                    paths: [fromDir],
-                });
+        catch (err) {
+            if (err.code !== 'MODULE_NOT_FOUND') {
+                throw err;
             }
-            catch (err) {
-                if (err.code !== 'MODULE_NOT_FOUND') {
-                    throw err;
-                }
-                if (!initialError) {
-                    initialError = err;
-                }
-                continue;
+            if (!initialError) {
+                initialError = err;
             }
-            if (filename.endsWith('.hbs') && !candidate.endsWith('.hbs')) {
-                // Evaluating the `handlebars` NPM package installs a Node extension
-                // that puts `*.hbs` in the automatic search path. But we can't control
-                // its priority, and it's really important to us that `.hbs` cannot
-                // shadow other extensions with higher priority. For example, when both
-                // `.ts` and `.hbs` exist, resolving is supposed to find the `.ts`.
-                //
-                // This covers the case where we found an hbs "by accident", when we
-                // weren't actually expecting it.
-                continue;
-            }
-            return { type: 'found', filename, result: { type: 'real', filename }, virtual: false };
+            continue;
+        }
+        if (filename.endsWith('.hbs') && !candidate.endsWith('.hbs')) {
+            // Evaluating the `handlebars` NPM package installs a Node extension
+            // that puts `*.hbs` in the automatic search path. But we can't control
+            // its priority, and it's really important to us that `.hbs` cannot
+            // shadow other extensions with higher priority. For example, when both
+            // `.ts` and `.hbs` exist, resolving is supposed to find the `.ts`.
+            //
+            // This covers the case where we found an hbs "by accident", when we
+            // weren't actually expecting it.
+            continue;
         }
-        return { type: 'not_found', err: initialError };
+        return { type: 'found', result: { type: 'real', filename } };
     }
+    return { type: 'not_found', err: initialError };
 }
-exports.NodeRequestAdapter = NodeRequestAdapter;
-NodeRequestAdapter.create = ({ resolver, specifier, fromFile, extensions }) => {
-    return {
-        initialState: {
-            specifier,
-            fromFile,
-            meta: undefined,
-        },
-        adapter: new NodeRequestAdapter(resolver, extensions),
-    };
-};
-const defaultExtensions = ['.hbs.js', '.hbs'];
 function* candidates(specifier, extensions) {
     yield specifier;
     for (let ext of extensions) {
         yield `${specifier}${ext}`;
     }
 }
-async function nodeResolve(resolver, specifier, fromFile, opts) {
-    var _a;
-    let request = module_request_1.ModuleRequest.create(NodeRequestAdapter.create, {
-        resolver,
-        fromFile,
-        specifier,
-        extensions: (_a = opts === null || opts === void 0 ? void 0 : opts.extensions) !== null && _a !== void 0 ? _a : defaultExtensions,
-    });
-    let resolution = await resolver.resolve(request);
-    switch (resolution.type) {
-        case 'not_found':
-            return resolution;
-        case 'found':
-            return resolution.result;
-        default:
-            throw (0, assert_never_1.default)(resolution);
-    }
-}
 //# sourceMappingURL=node-resolve.js.map

package/src/node-resolve.js.map

@@ -1 +1 @@
-{"version":3,"file":"node-resolve.js","sourceRoot":"","sources":["node-resolve.ts"],"names":[],"mappings":"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","sourcesContent":["import { virtualContent, type VirtualResponse } from './virtual-content';\nimport { dirname, resolve, isAbsolute } from 'path';\nimport { explicitRelative } from '@embroider/shared-internals';\nimport assertNever from 'assert-never';\n\n// these would be circular, but they're type-only so it's fine\nimport { ModuleRequest, type RequestAdapter, type RequestAdapterCreate, type Resolution } from './module-request';\nimport type { Resolver } from './module-resolver';\n\nexport class NodeRequestAdapter implements RequestAdapter<Resolution<NodeResolution, Error>> {\n  static create: RequestAdapterCreate<\n    { resolver: Resolver; specifier: string; fromFile: string; extensions: string[] },\n    Resolution<NodeResolution, Error>\n  > = ({ resolver, specifier, fromFile, extensions }) => {\n    return {\n      initialState: {\n        specifier,\n        fromFile,\n        meta: undefined,\n      },\n      adapter: new NodeRequestAdapter(resolver, extensions),\n    };\n  };\n\n  private constructor(private resolver: Resolver, private extensions: string[]) {}\n\n  get debugType() {\n    return 'node';\n  }\n\n  notFoundResponse(request: ModuleRequest<Resolution<NodeResolution, Error>>): Resolution<NodeResolution, Error> {\n    let err = new Error(`module not found ${request.specifier}`);\n    (err as any).code = 'MODULE_NOT_FOUND';\n    return {\n      type: 'not_found',\n      err,\n    };\n  }\n\n  virtualResponse(\n    _request: ModuleRequest<Resolution<NodeResolution, Error>>,\n    virtual: VirtualResponse\n  ): Resolution<NodeResolution, Error> {\n    return {\n      type: 'found',\n      filename: virtual.specifier,\n      virtual,\n      result: {\n        type: 'virtual' as const,\n        content: virtualContent(virtual, this.resolver).src,\n        filename: virtual.specifier,\n      },\n    };\n  }\n\n  async resolve(request: ModuleRequest<Resolution<NodeResolution, Error>>): Promise<Resolution<NodeResolution, Error>> {\n    // require.resolve does not like when we resolve from virtual paths.\n    // That is, a request like \"../thing.js\" from\n    // \"/a/real/path/VIRTUAL_SUBDIR/virtual.js\" has an unambiguous target of\n    // \"/a/real/path/thing.js\", but require.resolve won't do that path\n    // adjustment until after checking whether VIRTUAL_SUBDIR actually\n    // exists.\n    //\n    // We can do the path adjustments before doing require.resolve.\n    let { specifier } = request;\n    let fromDir = dirname(request.fromFile);\n    if (!isAbsolute(specifier) && specifier.startsWith('.')) {\n      let targetPath = resolve(fromDir, specifier);\n      let newFromDir = dirname(targetPath);\n      if (fromDir !== newFromDir) {\n        specifier = explicitRelative(newFromDir, targetPath);\n        fromDir = newFromDir;\n      }\n    }\n\n    let initialError;\n\n    for (let candidate of candidates(specifier, this.extensions)) {\n      let filename;\n      try {\n        filename = require.resolve(candidate, {\n          paths: [fromDir],\n        });\n      } catch (err) {\n        if (err.code !== 'MODULE_NOT_FOUND') {\n          throw err;\n        }\n\n        if (!initialError) {\n          initialError = err;\n        }\n\n        continue;\n      }\n      if (filename.endsWith('.hbs') && !candidate.endsWith('.hbs')) {\n        // Evaluating the `handlebars` NPM package installs a Node extension\n        // that puts `*.hbs` in the automatic search path. But we can't control\n        // its priority, and it's really important to us that `.hbs` cannot\n        // shadow other extensions with higher priority. For example, when both\n        // `.ts` and `.hbs` exist, resolving is supposed to find the `.ts`.\n        //\n        // This covers the case where we found an hbs \"by accident\", when we\n        // weren't actually expecting it.\n        continue;\n      }\n      return { type: 'found', filename, result: { type: 'real' as 'real', filename }, virtual: false };\n    }\n\n    return { type: 'not_found', err: initialError };\n  }\n}\n\nconst defaultExtensions = ['.hbs.js', '.hbs'];\n\nfunction* candidates(specifier: string, extensions: string[]) {\n  yield specifier;\n\n  for (let ext of extensions) {\n    yield `${specifier}${ext}`;\n  }\n}\n\ntype NodeResolution = { type: 'virtual'; filename: string; content: string } | { type: 'real'; filename: string };\n\ntype NodeResolutionError = { type: 'not_found'; err: Error };\n\nexport interface NodeResolveOpts {\n  extensions?: string[];\n}\n\nexport async function nodeResolve(\n  resolver: Resolver,\n  specifier: string,\n  fromFile: string,\n  opts?: NodeResolveOpts\n): Promise<NodeResolution | NodeResolutionError> {\n  let request = ModuleRequest.create(NodeRequestAdapter.create, {\n    resolver,\n    fromFile,\n    specifier,\n    extensions: opts?.extensions ?? defaultExtensions,\n  });\n  let resolution = await resolver.resolve(request!);\n  switch (resolution.type) {\n    case 'not_found':\n      return resolution;\n    case 'found':\n      return resolution.result;\n    default:\n      throw assertNever(resolution);\n  }\n}\n"]}
+{"version":3,"file":"node-resolve.js","sourceRoot":"","sources":["node-resolve.ts"],"names":[],"mappings":";;AAGA,0BAyDC;AA5DD,+BAAmE;AACnE,kEAA+D;AAE/D,SAAgB,OAAO,CACrB,SAAiB,EACjB,QAAgB,EAChB,UAAU,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC;IAEhC,oEAAoE;IACpE,6CAA6C;IAC7C,wEAAwE;IACxE,kEAAkE;IAClE,kEAAkE;IAClE,UAAU;IACV,EAAE;IACF,+DAA+D;IAC/D,IAAI,OAAO,GAAG,IAAA,cAAO,EAAC,QAAQ,CAAC,CAAC;IAChC,IAAI,CAAC,IAAA,iBAAU,EAAC,SAAS,CAAC,IAAI,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QACxD,IAAI,UAAU,GAAG,IAAA,cAAW,EAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QACjD,IAAI,UAAU,GAAG,IAAA,cAAO,EAAC,UAAU,CAAC,CAAC;QACrC,IAAI,OAAO,KAAK,UAAU,EAAE,CAAC;YAC3B,SAAS,GAAG,IAAA,mCAAgB,EAAC,UAAU,EAAE,UAAU,CAAC,CAAC;YACrD,OAAO,GAAG,UAAU,CAAC;QACvB,CAAC;IACH,CAAC;IAED,IAAI,YAAY,CAAC;IAEjB,KAAK,IAAI,SAAS,IAAI,UAAU,CAAC,SAAS,EAAE,UAAU,CAAC,EAAE,CAAC;QACxD,IAAI,QAAQ,CAAC;QACb,IAAI,CAAC;YACH,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE;gBACpC,KAAK,EAAE,CAAC,OAAO,CAAC;aACjB,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,GAAG,CAAC,IAAI,KAAK,kBAAkB,EAAE,CAAC;gBACpC,MAAM,GAAG,CAAC;YACZ,CAAC;YAED,IAAI,CAAC,YAAY,EAAE,CAAC;gBAClB,YAAY,GAAG,GAAG,CAAC;YACrB,CAAC;YAED,SAAS;QACX,CAAC;QACD,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YAC7D,oEAAoE;YACpE,uEAAuE;YACvE,mEAAmE;YACnE,uEAAuE;YACvE,mEAAmE;YACnE,EAAE;YACF,oEAAoE;YACpE,iCAAiC;YACjC,SAAS;QACX,CAAC;QACD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAgB,EAAE,QAAQ,EAAE,EAAE,CAAC;IACzE,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,GAAG,EAAE,YAAY,EAAE,CAAC;AAClD,CAAC;AAED,QAAQ,CAAC,CAAC,UAAU,CAAC,SAAiB,EAAE,UAAoB;IAC1D,MAAM,SAAS,CAAC;IAEhB,KAAK,IAAI,GAAG,IAAI,UAAU,EAAE,CAAC;QAC3B,MAAM,GAAG,SAAS,GAAG,GAAG,EAAE,CAAC;IAC7B,CAAC;AACH,CAAC","sourcesContent":["import { dirname, isAbsolute, resolve as pathResolve } from 'path';\nimport { explicitRelative } from '@embroider/shared-internals';\n\nexport function resolve(\n  specifier: string,\n  fromFile: string,\n  extensions = ['.hbs.js', '.hbs']\n): { type: 'found'; result: { type: 'real'; filename: string } } | { type: 'not_found'; err: Error } {\n  // require.resolve does not like when we resolve from virtual paths.\n  // That is, a request like \"../thing.js\" from\n  // \"/a/real/path/VIRTUAL_SUBDIR/virtual.js\" has an unambiguous target of\n  // \"/a/real/path/thing.js\", but require.resolve won't do that path\n  // adjustment until after checking whether VIRTUAL_SUBDIR actually\n  // exists.\n  //\n  // We can do the path adjustments before doing require.resolve.\n  let fromDir = dirname(fromFile);\n  if (!isAbsolute(specifier) && specifier.startsWith('.')) {\n    let targetPath = pathResolve(fromDir, specifier);\n    let newFromDir = dirname(targetPath);\n    if (fromDir !== newFromDir) {\n      specifier = explicitRelative(newFromDir, targetPath);\n      fromDir = newFromDir;\n    }\n  }\n\n  let initialError;\n\n  for (let candidate of candidates(specifier, extensions)) {\n    let filename;\n    try {\n      filename = require.resolve(candidate, {\n        paths: [fromDir],\n      });\n    } catch (err) {\n      if (err.code !== 'MODULE_NOT_FOUND') {\n        throw err;\n      }\n\n      if (!initialError) {\n        initialError = err;\n      }\n\n      continue;\n    }\n    if (filename.endsWith('.hbs') && !candidate.endsWith('.hbs')) {\n      // Evaluating the `handlebars` NPM package installs a Node extension\n      // that puts `*.hbs` in the automatic search path. But we can't control\n      // its priority, and it's really important to us that `.hbs` cannot\n      // shadow other extensions with higher priority. For example, when both\n      // `.ts` and `.hbs` exist, resolving is supposed to find the `.ts`.\n      //\n      // This covers the case where we found an hbs \"by accident\", when we\n      // weren't actually expecting it.\n      continue;\n    }\n    return { type: 'found', result: { type: 'real' as 'real', filename } };\n  }\n\n  return { type: 'not_found', err: initialError };\n}\n\nfunction* candidates(specifier: string, extensions: string[]) {\n  yield specifier;\n\n  for (let ext of extensions) {\n    yield `${specifier}${ext}`;\n  }\n}\n"]}

package/src/options.d.ts

@@ -55,10 +55,17 @@ export default interface Options {
     staticInvokables?: boolean;
     splitAtRoutes?: (RegExp | string)[];
     staticAppPaths?: string[];
+    skipBabel?: {
+        package: string;
+        semverRange?: string;
+    }[];
     pluginHints?: {
         resolve: string[];
         useMethod?: string;
     }[];
+    amdCompatibility?: false | 'cjs' | {
+        es: [string, string[]][];
+    };
 }
 export type CoreOptionsType = Required<Omit<Options, 'staticHelpers' | 'staticModifiers' | 'staticComponents' | 'staticInvokables'>> & Pick<Options, 'staticHelpers' | 'staticModifiers' | 'staticComponents' | 'staticInvokables'>;
 export declare function optionsWithDefaults(options?: Options): CoreOptionsType;

package/src/options.js

@@ -5,6 +5,7 @@ function optionsWithDefaults(options) {
     let defaults = {
         splitAtRoutes: [],
         staticAppPaths: [],
+        skipBabel: [],
         pluginHints: [],
         amdCompatibility: 'cjs',
     };

package/src/options.js.map

@@ -1 +1 @@
-{"version":3,"file":"options.js","sourceRoot":"","sources":["options.ts"],"names":[],"mappings":";;AA4GA,kDAWC;AAXD,SAAgB,mBAAmB,CAAC,OAAiB;IACnD,IAAI,QAAQ,GAAG;QACb,aAAa,EAAE,EAAE;QACjB,cAAc,EAAE,EAAE;QAClB,WAAW,EAAE,EAAE;QACf,gBAAgB,EAAE,KAAc;KACjC,CAAC;IACF,IAAI,OAAO,EAAE,CAAC;QACZ,OAAO,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC1C,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC","sourcesContent":["export default interface Options {\n  /**\n   * When true, we statically resolve all template helpers at build time. This\n   * causes unused helpers to be left out of the build (\"tree shaking\" of\n   * helpers).\n   *\n   * Defaults to false, which gives you greater compatibility with classic Ember\n   * apps at the cost of bigger builds.\n   *\n   * Enabling this is a prerequisite for route splitting.\n   *\n   * @deprecated use staticInvokables instead\n   */\n  staticHelpers?: boolean;\n\n  /**\n   * When true, we statically resolve all modifiers at build time. This\n   * causes unused modifiers to be left out of the build (\"tree shaking\" of\n   * modifiers).\n   *\n   * Defaults to false, which gives you greater compatibility with classic Ember\n   * apps at the cost of bigger builds.\n   *\n   * Enabling this is a prerequisite for route splitting.\n   *\n   * @deprecated use staticInvokables instead\n   */\n  staticModifiers?: boolean;\n\n  /**\n   * When true, we statically resolve all components at build time. This causes\n   * unused components to be left out of the build (\"tree shaking\" of\n   * components).\n   *\n   * Defaults to false, which gives you greater compatibility with classic Ember\n   * apps at the cost of bigger builds.\n   *\n   * Enabling this is a prerequisite for route splitting.\n   *\n   * @deprecated use staticInvokables instead\n   */\n  staticComponents?: boolean;\n\n  /**\n   * When true, we statically resolve all components, modifiers, and helpers (collectively\n   * knows as Invokables) at build time. This causes any unused Invokables to be left out\n   * of the build if they are unused i.e. \"tree shaking\".\n   *\n   * Defaults to false which gives you greater compatibility with classic Ember apps at the\n   * cost of bigger builds.\n   *\n   * This setting takes over from `staticHelpers`, `staticModifiers`, and `staticComponents`\n   * because the Developer Experience was less than ideal if any of these settings did not\n   * agree i.e. they all needed to be true or they all needed to be false.\n   *\n   * Enabling this is a prerequisite for route splitting.\n   */\n  staticInvokables?: boolean;\n\n  // Enables per-route code splitting. Any route names that match these patterns\n  // will be split out of the initial app payload. If you use this, you must\n  // also add @embroider/router to your app. See [@embroider/router's\n  // README](https://github.com/embroider-build/embroider/blob/main/packages/router/README.md)\n  splitAtRoutes?: (RegExp | string)[];\n\n  // Every file within your application's `app` directory is categorized as a\n  // component, helper, modifier, route, route template, controller, or \"other\".\n  //\n  // This option lets you decide which \"other\" files should be loaded\n  // statically. By default, all \"other\" files will be included in the build and\n  // registered with Ember's runtime loader, because we can't know if somebody\n  // is going to try to access them dynamically via Ember's resolver or AMD\n  // runtime `require`.\n  //\n  // If you know that your files are only ever imported, you can list them here\n  // and then they will only be included exactly where they're needed.\n  //\n  // Provide a list of directories or files relative to `/app`. For example\n  //\n  //     staticAppPaths: ['lib']\n  //\n  // means that everything under your-project/app/lib will be loaded statically.\n  //\n  // This option has no effect on components (which are governed by\n  // staticComponents), helpers (which are governed by staticHelpers), modifiers\n  // (which are governed by staticModifiers) or the route-specific files (routes,\n  // route templates, and controllers which are governed by splitAtRoutes).\n  staticAppPaths?: string[];\n\n  // This is a performance optimization that can help you avoid the \"Your build\n  // is slower because some babel plugins are non-serializable\" penalty. If you\n  // provide the locations of known non-serializable objects, we can discover\n  // them and make them serializable.\n  //\n  // resolve is a list of paths to resolve, in a chain. This lets you resolve\n  // your dependencies' dependencies, like: resolve: ['your-dependency',\n  // 'inner-dependency/lib/transform']\n  //\n  // useMethod optionally lets you pick which property within the module to use.\n  // If not provided, we use the module.exports itself.\n  pluginHints?: { resolve: string[]; useMethod?: string }[];\n}\n\nexport type CoreOptionsType = Required<\n  Omit<Options, 'staticHelpers' | 'staticModifiers' | 'staticComponents' | 'staticInvokables'>\n> &\n  Pick<Options, 'staticHelpers' | 'staticModifiers' | 'staticComponents' | 'staticInvokables'>;\n\nexport function optionsWithDefaults(options?: Options): CoreOptionsType {\n  let defaults = {\n    splitAtRoutes: [],\n    staticAppPaths: [],\n    pluginHints: [],\n    amdCompatibility: 'cjs' as const,\n  };\n  if (options) {\n    return Object.assign(defaults, options);\n  }\n  return defaults;\n}\n"]}
+{"version":3,"file":"options.js","sourceRoot":"","sources":["options.ts"],"names":[],"mappings":";;AA+JA,kDAYC;AAZD,SAAgB,mBAAmB,CAAC,OAAiB;IACnD,IAAI,QAAQ,GAAG;QACb,aAAa,EAAE,EAAE;QACjB,cAAc,EAAE,EAAE;QAClB,SAAS,EAAE,EAAE;QACb,WAAW,EAAE,EAAE;QACf,gBAAgB,EAAE,KAAc;KACjC,CAAC;IACF,IAAI,OAAO,EAAE,CAAC;QACZ,OAAO,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC1C,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC","sourcesContent":["export default interface Options {\n  /**\n   * When true, we statically resolve all template helpers at build time. This\n   * causes unused helpers to be left out of the build (\"tree shaking\" of\n   * helpers).\n   *\n   * Defaults to false, which gives you greater compatibility with classic Ember\n   * apps at the cost of bigger builds.\n   *\n   * Enabling this is a prerequisite for route splitting.\n   *\n   * @deprecated use staticInvokables instead\n   */\n  staticHelpers?: boolean;\n\n  /**\n   * When true, we statically resolve all modifiers at build time. This\n   * causes unused modifiers to be left out of the build (\"tree shaking\" of\n   * modifiers).\n   *\n   * Defaults to false, which gives you greater compatibility with classic Ember\n   * apps at the cost of bigger builds.\n   *\n   * Enabling this is a prerequisite for route splitting.\n   *\n   * @deprecated use staticInvokables instead\n   */\n  staticModifiers?: boolean;\n\n  /**\n   * When true, we statically resolve all components at build time. This causes\n   * unused components to be left out of the build (\"tree shaking\" of\n   * components).\n   *\n   * Defaults to false, which gives you greater compatibility with classic Ember\n   * apps at the cost of bigger builds.\n   *\n   * Enabling this is a prerequisite for route splitting.\n   *\n   * @deprecated use staticInvokables instead\n   */\n  staticComponents?: boolean;\n\n  /**\n   * When true, we statically resolve all components, modifiers, and helpers (collectively\n   * knows as Invokables) at build time. This causes any unused Invokables to be left out\n   * of the build if they are unused i.e. \"tree shaking\".\n   *\n   * Defaults to false which gives you greater compatibility with classic Ember apps at the\n   * cost of bigger builds.\n   *\n   * This setting takes over from `staticHelpers`, `staticModifiers`, and `staticComponents`\n   * because the Developer Experience was less than ideal if any of these settings did not\n   * agree i.e. they all needed to be true or they all needed to be false.\n   *\n   * Enabling this is a prerequisite for route splitting.\n   */\n  staticInvokables?: boolean;\n\n  // Enables per-route code splitting. Any route names that match these patterns\n  // will be split out of the initial app payload. If you use this, you must\n  // also add @embroider/router to your app. See [@embroider/router's\n  // README](https://github.com/embroider-build/embroider/blob/main/packages/router/README.md)\n  splitAtRoutes?: (RegExp | string)[];\n\n  // Every file within your application's `app` directory is categorized as a\n  // component, helper, modifier, route, route template, controller, or \"other\".\n  //\n  // This option lets you decide which \"other\" files should be loaded\n  // statically. By default, all \"other\" files will be included in the build and\n  // registered with Ember's runtime loader, because we can't know if somebody\n  // is going to try to access them dynamically via Ember's resolver or AMD\n  // runtime `require`.\n  //\n  // If you know that your files are only ever imported, you can list them here\n  // and then they will only be included exactly where they're needed.\n  //\n  // Provide a list of directories or files relative to `/app`. For example\n  //\n  //     staticAppPaths: ['lib']\n  //\n  // means that everything under your-project/app/lib will be loaded statically.\n  //\n  // This option has no effect on components (which are governed by\n  // staticComponents), helpers (which are governed by staticHelpers), modifiers\n  // (which are governed by staticModifiers) or the route-specific files (routes,\n  // route templates, and controllers which are governed by splitAtRoutes).\n  staticAppPaths?: string[];\n\n  // By default, all modules that get imported into the app go through Babel, so\n  // that all code will conform with your Babel targets. This option allows you\n  // to turn Babel off for a particular package. You might need this to work\n  // around a transpiler bug or you might use this as a build-performance\n  // optimization if you've manually verified that a particular package doesn't\n  // need transpilation to be safe in your target browsers.\n  skipBabel?: { package: string; semverRange?: string }[];\n\n  // This is a performance optimization that can help you avoid the \"Your build\n  // is slower because some babel plugins are non-serializable\" penalty. If you\n  // provide the locations of known non-serializable objects, we can discover\n  // them and make them serializable.\n  //\n  // resolve is a list of paths to resolve, in a chain. This lets you resolve\n  // your dependencies' dependencies, like: resolve: ['your-dependency',\n  // 'inner-dependency/lib/transform']\n  //\n  // useMethod optionally lets you pick which property within the module to use.\n  // If not provided, we use the module.exports itself.\n  pluginHints?: { resolve: string[]; useMethod?: string }[];\n\n  // Ember classically used a runtime AMD module loader.\n  //\n  // Embroider *can* locate the vast majority of modules statically, but when an\n  // addon is doing something highly dynamic (like injecting AMD `define()`\n  // statements directly into a <script>), we still may not be able to locate\n  // them. So Embroider can emit a placeholder shim for the missing module that\n  // attempts to locate it at runtime in the classic AMD loader.\n  //\n  // This shim can be generated as commonJS (cjs) or an ES module (es). The\n  // default is cjs.\n  //\n  // CJS is useful when you're building in an environment that is tolerant of\n  // mixed CJS and ES modules (like Webpack), because the set of exported names\n  // from the module doesn't need to be known in advance. For this reason, CJS\n  // shims are generated on-demand and are fully-automatic. This is the default\n  // for maximum backward-compatibility.\n  //\n  // ES is useful when you're building in a strict ES module environment (like\n  // Vite). It's fully spec-defined and doesn't suffer interoperability\n  // complexities. The downside is, we can only emit a correct shim for a module\n  // if you tell embroider what set of names it exports. Example:\n\n  // emberExternals: {\n  //   es: [\n  //     // import { first, second  } from \"my-library\";\n  //     ['my-library', ['first', 'second']],\n  //     // import Example from \"my-library/components/example\";\n  //     ['my-library/components/example', ['default']]\n  //   ];\n  // }\n\n  // It is not recommended to use `es` mode without also using\n  // staticEmberSource, because without staticEmberSource ember itself needs\n  // many external shims.\n  //\n  // false means we don't do any external shimming.\n  amdCompatibility?:\n    | false\n    | 'cjs'\n    | {\n        es: [string, string[]][];\n      };\n}\n\nexport type CoreOptionsType = Required<\n  Omit<Options, 'staticHelpers' | 'staticModifiers' | 'staticComponents' | 'staticInvokables'>\n> &\n  Pick<Options, 'staticHelpers' | 'staticModifiers' | 'staticComponents' | 'staticInvokables'>;\n\nexport function optionsWithDefaults(options?: Options): CoreOptionsType {\n  let defaults = {\n    splitAtRoutes: [],\n    staticAppPaths: [],\n    skipBabel: [],\n    pluginHints: [],\n    amdCompatibility: 'cjs' as const,\n  };\n  if (options) {\n    return Object.assign(defaults, options);\n  }\n  return defaults;\n}\n"]}

package/src/packager.d.ts

@@ -1,3 +1,4 @@
+import type { AppMeta } from '@embroider/shared-internals';
 export interface Variant {
     name: string;
     runtime: 'all' | 'browser' | 'fastboot';
@@ -11,6 +12,13 @@ export interface Packager {
     build(): Promise<void>;
 }
 export declare function applyVariantToBabelConfig(variant: Variant, babelConfig: any): any;
+/**
+ * Get the app meta-data for a package
+ */
+export declare function getAppMeta(pathToVanillaApp: string): {
+    name: string;
+    "ember-addon": AppMeta;
+};
 /**
  * Get the path to a cache directory in the recommended location
  *

package/src/packager.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyVariantToBabelConfig = applyVariantToBabelConfig;
+exports.getAppMeta = getAppMeta;
 exports.getPackagerCacheDir = getPackagerCacheDir;
 const shared_internals_1 = require("@embroider/shared-internals");
+const fs_extra_1 = require("fs-extra");
 const lodash_1 = require("lodash");
 const path_1 = require("path");
 function applyVariantToBabelConfig(variant, babelConfig) {
@@ -23,6 +25,13 @@ function applyVariantToBabelConfig(variant, babelConfig) {
     }
     return babelConfig;
 }
+/**
+ * Get the app meta-data for a package
+ */
+function getAppMeta(pathToVanillaApp) {
+    let pkg = JSON.parse((0, fs_extra_1.readFileSync)((0, path_1.join)(pathToVanillaApp, 'package.json'), 'utf8'));
+    return pkg;
+}
 /**
  * Get the path to a cache directory in the recommended location
  *

package/src/packager.js.map

@@ -1 +1 @@
-{"version":3,"file":"packager.js","sourceRoot":"","sources":["packager.ts"],"names":[],"mappings":";;AAsEA,8DAkBC;AAOD,kDAEC;AAjGD,kEAAqD;AACrD,mCAAmC;AACnC,+BAA4B;AAoE5B,SAAgB,yBAAyB,CAAC,OAAgB,EAAE,WAAgB;IAC1E,IAAI,OAAO,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;QACnC,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;QAC7C,IAAI,WAAW,CAAC,OAAO,EAAE,CAAC;YACxB,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QACpD,CAAC;aAAM,CAAC;YACN,WAAW,CAAC,OAAO,GAAG,EAAE,CAAC;QAC3B,CAAC;QACD,IAAI,WAAW,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CACxC,CAAC,CAAM,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,2BAA2B,CACzE,CAAC;QACF,IAAI,WAAW,EAAE,CAAC;YAChB,IAAI,mBAAmB,GAAG,IAAA,kBAAS,EAAC,WAAW,CAAC,CAAC;YACjD,mBAAmB,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,QAAQ,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;YACnE,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE,mBAAmB,CAAC,CAAC;QAC/F,CAAC;IACH,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;GAIG;AACH,SAAgB,mBAAmB,CAAC,IAAY;IAC9C,OAAO,IAAA,WAAI,EAAC,yBAAM,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;AACzC,CAAC","sourcesContent":["import { tmpdir } from '@embroider/shared-internals';\nimport { cloneDeep } from 'lodash';\nimport { join } from 'path';\n\n// This is a collection of flags that convey what kind of build you want. They\n// are intended to be generic across Packagers, and it's up to Packager authors\n// to support each option (or not).\nexport interface Variant {\n  // descriptive name that can be used by the packager to label which output\n  // goes with which variant.\n  name: string;\n\n  // Which runtime should this build work in? Dev builds will typically be \"all\"\n  // because we produce a single build that works in browser and fastboot. But\n  // production builds can be divided into a browser-only variant and a\n  // fastboot-only variant so that each can be separately optimized.\n  //\n  // Note that if you build *only* a fastboot variant, you're unlikely to end up\n  // with any assets that can boot and run in the browser too, so the typical\n  // thing to do is to have to two variants and for the packager to use the\n  // assets from the browser build to generate browser-facing <script> tags in\n  // the output of the fastboot build.\n  runtime: 'all' | 'browser' | 'fastboot';\n\n  // true if this build should be optimized for production, at the cost of\n  // slower builds and/or worse debuggability\n  optimizeForProduction: boolean;\n}\n\nexport interface PackagerConstructor<Options> {\n  new (\n    // where on disk the packager will find the app it's supposed to build. The\n    // app and its addons will necessarily already be in v2 format, which is\n    // what makes a Packager a cleanly separable stage that needs only a small\n    // amount of ember-specific knowledge.\n    inputPath: string,\n    // where the packager should write the packaged app.\n    outputPath: string,\n    // list of active build variants. There is always at least one variant, but\n    // there can be many.\n    //\n    // The main requirement for correctness is that the Packager is required to\n    // apply each variant to the babel and template-compiler configs that it\n    // finds in the app in order to build that variant.\n    //\n    // It is up to each Packager to decide how to combine the output from the\n    // multiple variants. It might choose to just put them in separate\n    // subdirectories of `outputPath`, or it might know how to combine them\n    // correctly into one build that will run each variant under the appropriate\n    // conditions.\n    //\n    // Not all packagers will support all arbitrary combinations of variants.\n    variants: Variant[],\n    // if possible, the packager should direct its console output through this\n    // hook.\n    consoleWrite: (message: string) => void,\n    // A packager can have whatever custom options type it wants here. If the\n    // packager is based on a third-party tool, this is where that tool's\n    // configuration can go.\n    options?: Options\n  ): Packager;\n\n  // a description for this packager that aids debugging & profiling\n  annotation: string;\n}\n\nexport interface Packager {\n  build(): Promise<void>;\n}\n\nexport function applyVariantToBabelConfig(variant: Variant, babelConfig: any) {\n  if (variant.runtime === 'fastboot') {\n    babelConfig = Object.assign({}, babelConfig);\n    if (babelConfig.plugins) {\n      babelConfig.plugins = babelConfig.plugins.slice();\n    } else {\n      babelConfig.plugins = [];\n    }\n    let macroPlugin = babelConfig.plugins.find(\n      (p: any) => Array.isArray(p) && p[1] && p[1].embroiderMacrosConfigMarker\n    );\n    if (macroPlugin) {\n      let modifiedMacroPlugin = cloneDeep(macroPlugin);\n      modifiedMacroPlugin[1].globalConfig.fastboot = { isRunning: true };\n      babelConfig.plugins.splice(babelConfig.plugins.indexOf(macroPlugin), 1, modifiedMacroPlugin);\n    }\n  }\n  return babelConfig;\n}\n\n/**\n * Get the path to a cache directory in the recommended location\n *\n * This ensures they have exactly the same lifetime as some of embroider's own caches.\n */\nexport function getPackagerCacheDir(name: string): string {\n  return join(tmpdir, 'embroider', name);\n}\n"]}
+{"version":3,"file":"packager.js","sourceRoot":"","sources":["packager.ts"],"names":[],"mappings":";;AAwEA,8DAkBC;AAKD,gCAGC;AAOD,kDAEC;AA1GD,kEAAqD;AACrD,uCAAwC;AACxC,mCAAmC;AACnC,+BAA4B;AAoE5B,SAAgB,yBAAyB,CAAC,OAAgB,EAAE,WAAgB;IAC1E,IAAI,OAAO,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;QACnC,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;QAC7C,IAAI,WAAW,CAAC,OAAO,EAAE,CAAC;YACxB,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QACpD,CAAC;aAAM,CAAC;YACN,WAAW,CAAC,OAAO,GAAG,EAAE,CAAC;QAC3B,CAAC;QACD,IAAI,WAAW,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CACxC,CAAC,CAAM,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,2BAA2B,CACzE,CAAC;QACF,IAAI,WAAW,EAAE,CAAC;YAChB,IAAI,mBAAmB,GAAG,IAAA,kBAAS,EAAC,WAAW,CAAC,CAAC;YACjD,mBAAmB,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,QAAQ,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;YACnE,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE,mBAAmB,CAAC,CAAC;QAC/F,CAAC;IACH,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;GAEG;AACH,SAAgB,UAAU,CAAC,gBAAwB;IACjD,IAAI,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAA,uBAAY,EAAC,IAAA,WAAI,EAAC,gBAAgB,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;IACnF,OAAO,GAA0D,CAAC;AACpE,CAAC;AAED;;;;GAIG;AACH,SAAgB,mBAAmB,CAAC,IAAY;IAC9C,OAAO,IAAA,WAAI,EAAC,yBAAM,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;AACzC,CAAC","sourcesContent":["import type { AppMeta } from '@embroider/shared-internals';\nimport { tmpdir } from '@embroider/shared-internals';\nimport { readFileSync } from 'fs-extra';\nimport { cloneDeep } from 'lodash';\nimport { join } from 'path';\n\n// This is a collection of flags that convey what kind of build you want. They\n// are intended to be generic across Packagers, and it's up to Packager authors\n// to support each option (or not).\nexport interface Variant {\n  // descriptive name that can be used by the packager to label which output\n  // goes with which variant.\n  name: string;\n\n  // Which runtime should this build work in? Dev builds will typically be \"all\"\n  // because we produce a single build that works in browser and fastboot. But\n  // production builds can be divided into a browser-only variant and a\n  // fastboot-only variant so that each can be separately optimized.\n  //\n  // Note that if you build *only* a fastboot variant, you're unlikely to end up\n  // with any assets that can boot and run in the browser too, so the typical\n  // thing to do is to have to two variants and for the packager to use the\n  // assets from the browser build to generate browser-facing <script> tags in\n  // the output of the fastboot build.\n  runtime: 'all' | 'browser' | 'fastboot';\n\n  // true if this build should be optimized for production, at the cost of\n  // slower builds and/or worse debuggability\n  optimizeForProduction: boolean;\n}\n\nexport interface PackagerConstructor<Options> {\n  new (\n    // where on disk the packager will find the app it's supposed to build. The\n    // app and its addons will necessarily already be in v2 format, which is\n    // what makes a Packager a cleanly separable stage that needs only a small\n    // amount of ember-specific knowledge.\n    inputPath: string,\n    // where the packager should write the packaged app.\n    outputPath: string,\n    // list of active build variants. There is always at least one variant, but\n    // there can be many.\n    //\n    // The main requirement for correctness is that the Packager is required to\n    // apply each variant to the babel and template-compiler configs that it\n    // finds in the app in order to build that variant.\n    //\n    // It is up to each Packager to decide how to combine the output from the\n    // multiple variants. It might choose to just put them in separate\n    // subdirectories of `outputPath`, or it might know how to combine them\n    // correctly into one build that will run each variant under the appropriate\n    // conditions.\n    //\n    // Not all packagers will support all arbitrary combinations of variants.\n    variants: Variant[],\n    // if possible, the packager should direct its console output through this\n    // hook.\n    consoleWrite: (message: string) => void,\n    // A packager can have whatever custom options type it wants here. If the\n    // packager is based on a third-party tool, this is where that tool's\n    // configuration can go.\n    options?: Options\n  ): Packager;\n\n  // a description for this packager that aids debugging & profiling\n  annotation: string;\n}\n\nexport interface Packager {\n  build(): Promise<void>;\n}\n\nexport function applyVariantToBabelConfig(variant: Variant, babelConfig: any) {\n  if (variant.runtime === 'fastboot') {\n    babelConfig = Object.assign({}, babelConfig);\n    if (babelConfig.plugins) {\n      babelConfig.plugins = babelConfig.plugins.slice();\n    } else {\n      babelConfig.plugins = [];\n    }\n    let macroPlugin = babelConfig.plugins.find(\n      (p: any) => Array.isArray(p) && p[1] && p[1].embroiderMacrosConfigMarker\n    );\n    if (macroPlugin) {\n      let modifiedMacroPlugin = cloneDeep(macroPlugin);\n      modifiedMacroPlugin[1].globalConfig.fastboot = { isRunning: true };\n      babelConfig.plugins.splice(babelConfig.plugins.indexOf(macroPlugin), 1, modifiedMacroPlugin);\n    }\n  }\n  return babelConfig;\n}\n\n/**\n * Get the app meta-data for a package\n */\nexport function getAppMeta(pathToVanillaApp: string) {\n  let pkg = JSON.parse(readFileSync(join(pathToVanillaApp, 'package.json'), 'utf8'));\n  return pkg as unknown as { name: string; 'ember-addon': AppMeta };\n}\n\n/**\n * Get the path to a cache directory in the recommended location\n *\n * This ensures they have exactly the same lifetime as some of embroider's own caches.\n */\nexport function getPackagerCacheDir(name: string): string {\n  return join(tmpdir, 'embroider', name);\n}\n"]}

package/src/portable-babel-config.d.ts

@@ -0,0 +1,11 @@
+import type { TransformOptions } from '@babel/core';
+import type { PortableHint } from './portable';
+export type ResolveOptions = {
+    basedir: string;
+} | {
+    resolve: (name: string) => any;
+};
+export declare function makePortable(config: TransformOptions, resolveOptions: ResolveOptions, hints: PortableHint[]): {
+    config: TransformOptions;
+    isParallelSafe: boolean;
+};

package/src/portable-babel-config.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePortable = makePortable;
+const path_1 = require("path");
+const resolve_1 = __importDefault(require("resolve"));
+const portable_1 = require("./portable");
+function makePortable(config, resolveOptions, hints) {
+    return new PortableBabelConfig(resolveOptions, hints).convert(config);
+}
+class PortableBabelConfig {
+    constructor(resolveOptions, hints) {
+        this.hints = hints;
+        if ('resolve' in resolveOptions) {
+            this.resolve = resolveOptions.resolve;
+        }
+        else {
+            this.basedir = resolveOptions.basedir;
+            this.resolve = (name) => resolve_1.default.sync(name, { basedir: resolveOptions.basedir });
+        }
+    }
+    convert(config) {
+        let portable = new portable_1.Portable({
+            hints: this.hints,
+            dehydrate: (value, accessPath) => {
+                // this custom dehydrate hook handles babel plugins & presets. If we're
+                // not looking at plugins or presets, continue with stock Portable
+                // behavior
+                if (accessPath.length !== 2 || (accessPath[0] !== 'plugins' && accessPath[0] !== 'presets')) {
+                    return undefined;
+                }
+                // standardize to always handle an array
+                if (!Array.isArray(value)) {
+                    value = [value];
+                }
+                let [plugin, argument, asName] = value;
+                // string plugins need to get resolved correctly into absolute paths,
+                // so they will really be portable
+                if (typeof plugin === 'string') {
+                    plugin = this.resolveBabelPlugin(plugin);
+                }
+                // next we deal with serializability. Our Portable system already
+                // understands the protocol used by ember-cli-babel to identify plugin
+                // classes and get back to their serializable forms, so this will
+                // handle that case.
+                let dehydrated = portable.dehydrate([plugin, argument, asName], accessPath.concat('_internal'));
+                if (dehydrated.needsHydrate) {
+                    // we can eliminate the need for rehydration by going through our own
+                    // portable babel launcher
+                    return {
+                        value: [
+                            (0, path_1.join)(__dirname, 'portable-babel-launcher.js'),
+                            { module: dehydrated.value[0], arg: dehydrated.value[1], hints: this.hints },
+                            dehydrated.value[2] || `portable-babel-launcher-${accessPath[1]}`,
+                        ],
+                        needsHydrate: false,
+                        isParallelSafe: dehydrated.isParallelSafe,
+                    };
+                }
+                else {
+                    // trim back down our array, because trailing undefined will get
+                    // converted into null via json.stringify, and babel will complain
+                    // about that.
+                    while (dehydrated.value.length > 0 && dehydrated.value[dehydrated.value.length - 1] == null) {
+                        dehydrated.value.pop();
+                    }
+                    if (dehydrated.value.length === 1) {
+                        dehydrated.value = dehydrated.value[0];
+                    }
+                    return {
+                        value: dehydrated.value,
+                        needsHydrate: dehydrated.needsHydrate,
+                        isParallelSafe: dehydrated.isParallelSafe,
+                    };
+                }
+            },
+        });
+        let result = portable.dehydrate(config);
+        if (result.needsHydrate) {
+            throw new Error(`bug: portable babel configs aren't supposed to need hydration`);
+        }
+        return { config: result.value, isParallelSafe: result.isParallelSafe };
+    }
+    // babel lets you use relative paths, absolute paths, package names, and
+    // package name shorthands.
+    //
+    // my-plugin  -> my-plugin
+    // my-plugin  -> babel-plugin-my-plugin
+    // @me/thing  -> @me/thing
+    // @me/thing  -> @me/babel-plugin-thing
+    // ./here     -> /your/app/here
+    // /tmp/there -> /tmp/there
+    //
+    resolveBabelPlugin(name) {
+        try {
+            return this.resolve(name);
+        }
+        catch (err) {
+            if (err.code !== 'MODULE_NOT_FOUND') {
+                throw err;
+            }
+            if (name.startsWith('.') || name.startsWith('/')) {
+                throw err;
+            }
+            try {
+                let expanded;
+                if (name.startsWith('@')) {
+                    let [space, pkg, ...rest] = name.split('/');
+                    expanded = [space, `babel-plugin-${pkg}`, ...rest].join('/');
+                }
+                else {
+                    expanded = `babel-plugin-${name}`;
+                }
+                return this.resolve(expanded);
+            }
+            catch (err2) {
+                if (err2.code !== 'MODULE_NOT_FOUND') {
+                    throw err2;
+                }
+                if (this.basedir) {
+                    throw new Error(`unable to resolve babel plugin ${name} from ${this.basedir}`);
+                }
+                else {
+                    throw new Error(`unable to resolve babel plugin ${name}`);
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=portable-babel-config.js.map

package/src/portable-babel-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"portable-babel-config.js","sourceRoot":"","sources":["portable-babel-config.ts"],"names":[],"mappings":"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","sourcesContent":["import type { TransformOptions } from '@babel/core';\nimport { join } from 'path';\nimport resolve from 'resolve';\nimport type { PortableHint } from './portable';\nimport { Portable } from './portable';\n\nexport type ResolveOptions = { basedir: string } | { resolve: (name: string) => any };\n\nexport function makePortable(\n  config: TransformOptions,\n  resolveOptions: ResolveOptions,\n  hints: PortableHint[]\n): { config: TransformOptions; isParallelSafe: boolean } {\n  return new PortableBabelConfig(resolveOptions, hints).convert(config);\n}\n\nclass PortableBabelConfig {\n  private resolve: (name: string) => any;\n  private basedir: string | undefined;\n\n  constructor(resolveOptions: ResolveOptions, private hints: PortableHint[]) {\n    if ('resolve' in resolveOptions) {\n      this.resolve = resolveOptions.resolve;\n    } else {\n      this.basedir = resolveOptions.basedir;\n      this.resolve = (name: string) => resolve.sync(name, { basedir: resolveOptions.basedir });\n    }\n  }\n\n  convert(config: TransformOptions): { config: TransformOptions; isParallelSafe: boolean } {\n    let portable: Portable = new Portable({\n      hints: this.hints,\n      dehydrate: (value: any, accessPath: string[]) => {\n        // this custom dehydrate hook handles babel plugins & presets. If we're\n        // not looking at plugins or presets, continue with stock Portable\n        // behavior\n        if (accessPath.length !== 2 || (accessPath[0] !== 'plugins' && accessPath[0] !== 'presets')) {\n          return undefined;\n        }\n\n        // standardize to always handle an array\n        if (!Array.isArray(value)) {\n          value = [value];\n        }\n\n        let [plugin, argument, asName] = value;\n\n        // string plugins need to get resolved correctly into absolute paths,\n        // so they will really be portable\n        if (typeof plugin === 'string') {\n          plugin = this.resolveBabelPlugin(plugin);\n        }\n\n        // next we deal with serializability. Our Portable system already\n        // understands the protocol used by ember-cli-babel to identify plugin\n        // classes and get back to their serializable forms, so this will\n        // handle that case.\n        let dehydrated = portable.dehydrate([plugin, argument, asName], accessPath.concat('_internal'));\n\n        if (dehydrated.needsHydrate) {\n          // we can eliminate the need for rehydration by going through our own\n          // portable babel launcher\n          return {\n            value: [\n              join(__dirname, 'portable-babel-launcher.js'),\n              { module: dehydrated.value[0], arg: dehydrated.value[1], hints: this.hints },\n              dehydrated.value[2] || `portable-babel-launcher-${accessPath[1]}`,\n            ],\n            needsHydrate: false,\n            isParallelSafe: dehydrated.isParallelSafe,\n          };\n        } else {\n          // trim back down our array, because trailing undefined will get\n          // converted into null via json.stringify, and babel will complain\n          // about that.\n          while (dehydrated.value.length > 0 && dehydrated.value[dehydrated.value.length - 1] == null) {\n            dehydrated.value.pop();\n          }\n          if (dehydrated.value.length === 1) {\n            dehydrated.value = dehydrated.value[0];\n          }\n          return {\n            value: dehydrated.value,\n            needsHydrate: dehydrated.needsHydrate,\n            isParallelSafe: dehydrated.isParallelSafe,\n          };\n        }\n      },\n    });\n    let result = portable.dehydrate(config);\n    if (result.needsHydrate) {\n      throw new Error(`bug: portable babel configs aren't supposed to need hydration`);\n    }\n    return { config: result.value, isParallelSafe: result.isParallelSafe };\n  }\n\n  // babel lets you use relative paths, absolute paths, package names, and\n  // package name shorthands.\n  //\n  // my-plugin  -> my-plugin\n  // my-plugin  -> babel-plugin-my-plugin\n  // @me/thing  -> @me/thing\n  // @me/thing  -> @me/babel-plugin-thing\n  // ./here     -> /your/app/here\n  // /tmp/there -> /tmp/there\n  //\n  private resolveBabelPlugin(name: string) {\n    try {\n      return this.resolve(name);\n    } catch (err) {\n      if (err.code !== 'MODULE_NOT_FOUND') {\n        throw err;\n      }\n      if (name.startsWith('.') || name.startsWith('/')) {\n        throw err;\n      }\n      try {\n        let expanded;\n        if (name.startsWith('@')) {\n          let [space, pkg, ...rest] = name.split('/');\n          expanded = [space, `babel-plugin-${pkg}`, ...rest].join('/');\n        } else {\n          expanded = `babel-plugin-${name}`;\n        }\n        return this.resolve(expanded);\n      } catch (err2) {\n        if (err2.code !== 'MODULE_NOT_FOUND') {\n          throw err2;\n        }\n        if (this.basedir) {\n          throw new Error(`unable to resolve babel plugin ${name} from ${this.basedir}`);\n        } else {\n          throw new Error(`unable to resolve babel plugin ${name}`);\n        }\n      }\n    }\n  }\n}\n"]}

package/src/portable-babel-launcher.d.ts

@@ -0,0 +1,6 @@
+import type { PortableHint } from './portable';
+export default function babelLauncher(this: any, babel: any, launch: {
+    module: any;
+    arg: any;
+    hints: PortableHint[];
+}, key: string): any;

package/src/portable-babel-launcher.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = babelLauncher;
+const portable_1 = require("./portable");
+function babelLauncher(babel, launch, key) {
+    let p = new portable_1.Portable({ hints: launch.hints });
+    let hydrated = p.hydrate(launch);
+    let module;
+    if (typeof hydrated.module === 'string') {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        module = require(hydrated.module);
+        if (module.__esModule) {
+            module = module.default;
+        }
+    }
+    else {
+        module = hydrated.module;
+    }
+    let plugin = module.call(this, babel, hydrated.arg, key);
+    let innerStates = new WeakMap();
+    function convertState(state) {
+        let innerState = innerStates.get(state);
+        if (!innerState) {
+            innerState = Object.assign({}, state, { opts: hydrated.arg });
+            innerStates.set(state, innerState);
+        }
+        return innerState;
+    }
+    function wrap1(original) {
+        if (typeof original === 'function') {
+            return function (file) {
+                return original.call(convertState(this), file);
+            };
+        }
+    }
+    function wrap2(original) {
+        return function (path, state) {
+            return original.call(convertState(this), path, convertState(state));
+        };
+    }
+    let visitorProxy = {
+        get(target, prop) {
+            let original = target[prop];
+            if (typeof original === 'function') {
+                return wrap2(original);
+            }
+            if (original && typeof original === 'object') {
+                let wrapped = {};
+                if (typeof original.exit === 'function') {
+                    wrapped.exit = wrap2(original.exit);
+                }
+                if (typeof original.enter === 'function') {
+                    wrapped.enter = wrap2(original.enter);
+                }
+                return wrapped;
+            }
+            return original;
+        },
+    };
+    return new Proxy(plugin, {
+        get(target, prop) {
+            let original = target[prop];
+            switch (prop) {
+                case 'pre':
+                case 'post':
+                    return wrap1(original);
+                case 'visitor':
+                    return new Proxy(original, visitorProxy);
+                default:
+                    return original;
+            }
+        },
+    });
+}
+//# sourceMappingURL=portable-babel-launcher.js.map

package/src/portable-babel-launcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"portable-babel-launcher.js","sourceRoot":"","sources":["portable-babel-launcher.ts"],"names":[],"mappings":"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","sourcesContent":["import type { PortableHint } from './portable';\nimport { Portable } from './portable';\n\nexport default function babelLauncher(\n  this: any,\n  babel: any,\n  launch: { module: any; arg: any; hints: PortableHint[] },\n  key: string\n) {\n  let p = new Portable({ hints: launch.hints });\n  let hydrated = p.hydrate(launch);\n  let module;\n  if (typeof hydrated.module === 'string') {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    module = require(hydrated.module);\n    if (module.__esModule) {\n      module = module.default;\n    }\n  } else {\n    module = hydrated.module;\n  }\n\n  let plugin = module.call(this, babel, hydrated.arg, key);\n  let innerStates = new WeakMap();\n\n  function convertState(state: any) {\n    let innerState = innerStates.get(state);\n    if (!innerState) {\n      innerState = Object.assign({}, state, { opts: hydrated.arg });\n      innerStates.set(state, innerState);\n    }\n    return innerState;\n  }\n\n  function wrap1(original: any) {\n    if (typeof original === 'function') {\n      return function (this: any, file: any) {\n        return original.call(convertState(this), file);\n      };\n    }\n  }\n\n  function wrap2(original: Function) {\n    return function (this: any, path: any, state: any) {\n      return original.call(convertState(this), path, convertState(state));\n    };\n  }\n\n  let visitorProxy = {\n    get(target: any, prop: string) {\n      let original = target[prop];\n      if (typeof original === 'function') {\n        return wrap2(original);\n      }\n      if (original && typeof original === 'object') {\n        let wrapped: any = {};\n        if (typeof original.exit === 'function') {\n          wrapped.exit = wrap2(original.exit);\n        }\n        if (typeof original.enter === 'function') {\n          wrapped.enter = wrap2(original.enter);\n        }\n        return wrapped;\n      }\n      return original;\n    },\n  };\n\n  return new Proxy(plugin, {\n    get(target, prop) {\n      let original = target[prop];\n      switch (prop) {\n        case 'pre':\n        case 'post':\n          return wrap1(original);\n        case 'visitor':\n          return new Proxy(original, visitorProxy);\n        default:\n          return original;\n      }\n    },\n  });\n}\n"]}