@embroider/macros 1.21.2 → 1.21.3

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-config.js","sourceRoot":"","sources":["get-config.ts"],"names":[],"mappings":";;;;;AAmCA,4BAUC;AAKD,oCAyBC;AAiCD,kDAMC;AA/GD,oDAA4B;AAE5B,mDAAwE;AACxE,gEAAuC;AAMvC,SAAS,UAAU,CAAC,IAAgC,EAAE,KAAY,EAAE,IAAuB;IACzF,IAAI,WAA+B,CAAC;IACpC,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;QACnB,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACrC,MAAM,IAAA,eAAK,EAAC,IAAI,EAAE,iDAAiD,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC;QACnG,CAAC;QACD,WAAW,GAAG,SAAS,CAAC;IAC1B,CAAC;SAAM,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QAC9B,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACrC,MAAM,IAAA,eAAK,EAAC,IAAI,EAAE,oDAAoD,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC;QACtG,CAAC;QACD,IAAI,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;QACzC,IAAI,WAAW,CAAC,IAAI,KAAK,eAAe,EAAE,CAAC;YACzC,MAAM,IAAA,eAAK,EAAC,IAAA,2BAAW,EAAC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,oDAAoD,CAAC,CAAC;QAC3G,CAAC;QACD,WAAW,GAAG,WAAW,CAAC,KAAK,CAAC;IAClC,CAAC;SAAM,CAAC;QACN,IAAA,sBAAW,EAAC,IAAI,CAAC,CAAC;IACpB,CAAC;IACD,OAAO,aAAa,CAAC,KAAK,CAAC,qBAAqB,EAAE,EAAE,WAAW,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;AACvF,CAAC;AAED,8FAA8F;AAC9F,SAAwB,SAAS,CAAC,IAAgC,EAAE,KAAY,EAAE,IAAU;IAC1F,IAAI,MAA2B,CAAC;IAChC,IAAI,IAAI,KAAK,iBAAiB,EAAE,CAAC;QAC/B,OAAO,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC;IACjC,CAAC;IACD,IAAI,GAAG,GAAG,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IACxC,IAAI,GAAG,EAAE,CAAC;QACR,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,8EAA8E;AAC9E,gFAAgF;AAChF,sCAAsC;AACtC,SAAgB,YAAY,CAAC,IAAgC,EAAE,KAAY,EAAE,IAAU,EAAE,OAAqB;IAC5G,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;QACvC,IAAI,MAAM,GAAG,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;QAC1C,IAAI,SAAS,GAAG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACvC,IAAI,aAAa,GAAG,IAAA,6BAAa,EAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC7D,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;IAC5C,CAAC;SAAM,CAAC;QACN,IAAI,IAAI,KAAK,iBAAiB,EAAE,CAAC;YAC/B,IAAI,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YAChC,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,cAAc,CAAC,SAAS,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC;QAC1G,CAAC;aAAM,CAAC;YACN,IAAI,GAAG,GAAG,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;YACxC,IAAI,OAAO,CAAC;YACZ,IAAI,GAAG,EAAE,CAAC;gBACR,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAClD,CAAC;iBAAM,CAAC;gBACN,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;YAClD,CAAC;YACD,IAAI,CAAC,WAAW,CACd,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,cAAc,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,EAAE;gBACrG,OAAO;aACR,CAAC,CACH,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC;AAED,SAAS,aAAa,CACpB,EAAW,EACX,WAA+B,EAC/B,YAAmC;IAEnC,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,IAAI,CAAC;QACH,IAAI,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;QACnD,OAAO,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACvC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,SAAS,QAAQ,CAAC,IAAc,EAAE,MAAe;IAC/C,IAAI,SAAS,GAAG,IAAI,yBAAS,CAAC;QAC5B,UAAU,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,wBAAwB,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;KACnG,CAAC,CAAC;IAEH,OAAO,IAAI,EAAE,CAAC;QACZ,IAAI,UAAU,GAAG,IAAI,CAAC,UAAW,CAAC;QAClC,IAAI,MAAM,GAAG,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;QAC5C,IAAI,CAAC,MAAM,CAAC,SAAS,IAAI,UAAU,CAAC,sBAAsB,EAAE,EAAE,CAAC;YAC7D,OAAO,EAAE,IAAI,EAAE,MAAM,EAAG,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAqB,CAAC,KAAK,EAAE,CAAC;QAC/E,CAAC;QACD,IAAI,GAAG,UAAU,CAAC;IACpB,CAAC;AACH,CAAC;AAED,SAAgB,mBAAmB,CAAC,IAAqC,EAAE,KAAY,EAAE,OAAqB;IAC5G,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,GAAG;QAC3B,OAAO,CAAC,KAAK,CAAC,eAAe,CAC3B,IAAA,6BAAa,EAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,YAAY,EAAE,EAAE,OAAO,CAAC,CAC9F;KACF,CAAC;AACJ,CAAC","sourcesContent":["import type { NodePath } from '@babel/traverse';\nimport type State from './state';\nimport type { RewrittenPackageCache, Package } from '@embroider/shared-internals';\nimport error from './error';\nimport type { ConfidentResult } from './evaluate-json';\nimport { Evaluator, assertArray, buildLiterals } from './evaluate-json';\nimport assertNever from 'assert-never';\nimport type * as Babel from '@babel/core';\nimport type { types as t } from '@babel/core';\n\nexport type Mode = 'own' | 'getGlobalConfig' | 'package';\n\nfunction getPackage(path: NodePath<t.CallExpression>, state: State, mode: 'own' | 'package'): { root: string } | null {\n  let packageName: string | undefined;\n  if (mode === 'own') {\n    if (path.node.arguments.length !== 0) {\n      throw error(path, `getOwnConfig takes zero arguments, you passed ${path.node.arguments.length}`);\n    }\n    packageName = undefined;\n  } else if (mode === 'package') {\n    if (path.node.arguments.length !== 1) {\n      throw error(path, `getConfig takes exactly one argument, you passed ${path.node.arguments.length}`);\n    }\n    let packageNode = path.node.arguments[0];\n    if (packageNode.type !== 'StringLiteral') {\n      throw error(assertArray(path.get('arguments'))[0], `the argument to getConfig must be a string literal`);\n    }\n    packageName = packageNode.value;\n  } else {\n    assertNever(mode);\n  }\n  return targetPackage(state.originalOwningPackage(), packageName, state.packageCache);\n}\n\n// this evaluates to the actual value of the config. It can be used directly by the Evaluator.\nexport default function getConfig(path: NodePath<t.CallExpression>, state: State, mode: Mode) {\n  let config: unknown | undefined;\n  if (mode === 'getGlobalConfig') {\n    return state.opts.globalConfig;\n  }\n  let pkg = getPackage(path, state, mode);\n  if (pkg) {\n    config = state.opts.userConfigs[pkg.root];\n  }\n  return config;\n}\n\n// this is the imperative version that's invoked directly by the babel visitor\n// when we encounter getConfig. It's implemented in terms of getConfig so we can\n// be sure we have the same semantics.\nexport function insertConfig(path: NodePath<t.CallExpression>, state: State, mode: Mode, context: typeof Babel) {\n  if (state.opts.mode === 'compile-time') {\n    let config = getConfig(path, state, mode);\n    let collapsed = collapse(path, config);\n    let literalResult = buildLiterals(collapsed.config, context);\n    collapsed.path.replaceWith(literalResult);\n  } else {\n    if (mode === 'getGlobalConfig') {\n      let callee = path.get('callee');\n      callee.replaceWith(state.importUtil.import(callee, state.pathToOurAddon('runtime'), 'getGlobalConfig'));\n    } else {\n      let pkg = getPackage(path, state, mode);\n      let pkgRoot;\n      if (pkg) {\n        pkgRoot = context.types.stringLiteral(pkg.root);\n      } else {\n        pkgRoot = context.types.identifier('undefined');\n      }\n      path.replaceWith(\n        context.types.callExpression(state.importUtil.import(path, state.pathToOurAddon('runtime'), 'config'), [\n          pkgRoot,\n        ])\n      );\n    }\n  }\n}\n\nfunction targetPackage(\n  us: Package,\n  packageName: string | undefined,\n  packageCache: RewrittenPackageCache\n): Package | null {\n  if (!packageName) {\n    return us;\n  }\n  try {\n    let target = packageCache.resolve(packageName, us);\n    return packageCache.original(target);\n  } catch (err) {\n    return null;\n  }\n}\n\nfunction collapse(path: NodePath, config: unknown) {\n  let evaluator = new Evaluator({\n    knownPaths: new Map([[path, { confident: true, value: config, hasRuntimeImplementation: false }]]),\n  });\n\n  while (true) {\n    let parentPath = path.parentPath!;\n    let result = evaluator.evaluate(parentPath);\n    if (!result.confident || parentPath.isAssignmentExpression()) {\n      return { path, config: (evaluator.evaluate(path) as ConfidentResult).value };\n    }\n    path = parentPath;\n  }\n}\n\nexport function inlineRuntimeConfig(path: NodePath<t.FunctionDeclaration>, state: State, context: typeof Babel) {\n  path.get('body').node.body = [\n    context.types.returnStatement(\n      buildLiterals({ packages: state.opts.userConfigs, global: state.opts.globalConfig }, context)\n    ),\n  ];\n}\n"]}

package/src/babel/import-sync-pattern.d.ts

@@ -0,0 +1,22 @@
+import type * as Babel from '@babel/core';
+import type { types as t } from '@babel/core';
+type Types = typeof Babel.types;
+export type PatternPart = {
+    type: 'static';
+    value: string;
+} | {
+    type: 'dynamic';
+    value: t.Expression;
+};
+export interface ParsedSpecifier {
+    dir: string;
+    pattern: PatternPart[];
+}
+export declare function patternParts(types: Types, specifier: t.Node): PatternPart[] | undefined;
+export declare function parseSpecifier(parts: PatternPart[]): ParsedSpecifier | undefined;
+export declare function entryKey(entry: string): string;
+export declare function patternMatcher(pattern: PatternPart[]): (key: string) => boolean;
+export declare function lookupExpression(types: Types, pattern: PatternPart[]): t.Expression;
+export declare function relativeSpecifier(path: string): string;
+export {};
+//# sourceMappingURL=import-sync-pattern.d.ts.map

package/src/babel/import-sync-pattern.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patternParts = patternParts;
+exports.parseSpecifier = parseSpecifier;
+exports.entryKey = entryKey;
+exports.patternMatcher = patternMatcher;
+exports.lookupExpression = lookupExpression;
+exports.relativeSpecifier = relativeSpecifier;
+// Turns a specifier expression into a flat list of static and dynamic parts.
+// Returns undefined if this isn't a shape we understand.
+function patternParts(types, specifier) {
+    if (specifier.type === 'TemplateLiteral') {
+        let parts = [];
+        for (let [index, quasi] of specifier.quasis.entries()) {
+            parts.push({ type: 'static', value: quasi.value.cooked });
+            let expression = specifier.expressions[index];
+            if (expression) {
+                if (!types.isExpression(expression)) {
+                    return undefined;
+                }
+                parts.push({ type: 'dynamic', value: expression });
+            }
+        }
+        return normalize(parts);
+    }
+    // babel might transform the template form `../my-path/${id}` into
+    // '../my-path/'.concat(id)
+    if (specifier.type === 'CallExpression' &&
+        specifier.callee.type === 'MemberExpression' &&
+        specifier.callee.property.type === 'Identifier' &&
+        specifier.callee.property.name === 'concat' &&
+        specifier.callee.object.type === 'StringLiteral') {
+        let parts = [{ type: 'static', value: specifier.callee.object.value }];
+        for (let arg of specifier.arguments) {
+            if (arg.type === 'StringLiteral') {
+                parts.push({ type: 'static', value: arg.value });
+            }
+            else if (types.isExpression(arg)) {
+                parts.push({ type: 'dynamic', value: arg });
+            }
+            else {
+                return undefined;
+            }
+        }
+        return normalize(parts);
+    }
+    return undefined;
+}
+// merges adjacent static parts and drops empty ones, so that the rest of the
+// code can assume statics are maximal and non-empty
+function normalize(parts) {
+    let output = [];
+    for (let part of parts) {
+        if (part.type === 'static') {
+            if (part.value === '') {
+                continue;
+            }
+            let previous = output[output.length - 1];
+            if ((previous === null || previous === void 0 ? void 0 : previous.type) === 'static') {
+                output[output.length - 1] = { type: 'static', value: previous.value + part.value };
+                continue;
+            }
+        }
+        output.push(part);
+    }
+    return output;
+}
+// Splits the parts into the directory we're going to read and the pattern that
+// entries in it need to match. Returns undefined when the parts don't describe
+// a relative path with a statically-known directory.
+function parseSpecifier(parts) {
+    let first = parts[0];
+    if ((first === null || first === void 0 ? void 0 : first.type) !== 'static' || !first.value.startsWith('.')) {
+        return undefined;
+    }
+    let slash = first.value.lastIndexOf('/');
+    if (slash === -1) {
+        return undefined;
+    }
+    let dir = first.value.slice(0, slash + 1);
+    let head = first.value.slice(slash + 1);
+    let pattern = normalize([{ type: 'static', value: head }, ...parts.slice(1)]);
+    // The directory we read is only one level deep, so a "/" anywhere later in
+    // the pattern could never match one of its entries.
+    if (pattern.some(part => part.type === 'static' && part.value.includes('/'))) {
+        return undefined;
+    }
+    return { dir, pattern: withoutExtension(pattern) };
+}
+// The lookup table is keyed by extension-less filenames, because that's what we
+// hand to the resolver. So if the author wrote the extension (which is what
+// Vite's own dynamic import rules ask for) we drop it from the pattern too.
+function withoutExtension(pattern) {
+    let last = pattern[pattern.length - 1];
+    if ((last === null || last === void 0 ? void 0 : last.type) !== 'static') {
+        return pattern;
+    }
+    let stripped = last.value.replace(/\.\w+$/, '');
+    if (stripped === last.value) {
+        return pattern;
+    }
+    return normalize([...pattern.slice(0, -1), { type: 'static', value: stripped }]);
+}
+// The key we use for a directory entry: its name minus the file extension.
+function entryKey(entry) {
+    let dot = entry.lastIndexOf('.');
+    return dot === -1 ? entry : entry.slice(0, dot);
+}
+// Which keys could this pattern actually select? Everything else in the
+// directory would be dead weight in the bundle.
+function patternMatcher(pattern) {
+    let source = '^' + pattern.map(part => (part.type === 'static' ? escapeRegExp(part.value) : '[\\s\\S]*')).join('') + '$';
+    let regex = new RegExp(source);
+    return key => regex.test(key);
+}
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// Builds the expression we use to index into the lookup table. When the pattern
+// is a single interpolation (the only shape that used to work) this is just that
+// expression, so existing call sites compile to byte-identical output.
+function lookupExpression(types, pattern) {
+    if (pattern.length === 1 && pattern[0].type === 'dynamic') {
+        return pattern[0].value;
+    }
+    let quasis = [];
+    let expressions = [];
+    let pending = '';
+    for (let part of pattern) {
+        if (part.type === 'static') {
+            pending += part.value;
+        }
+        else {
+            quasis.push(types.templateElement({ raw: escapeTemplate(pending), cooked: pending }));
+            pending = '';
+            expressions.push(part.value);
+        }
+    }
+    quasis.push(types.templateElement({ raw: escapeTemplate(pending), cooked: pending }, true));
+    return types.templateLiteral(quasis, expressions);
+}
+function escapeTemplate(str) {
+    return str.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}
+// path.join() will strip a leading "./", which would turn our relative path
+// into a bare package specifier.
+function relativeSpecifier(path) {
+    let normalized = path.replace(/\\/g, '/');
+    return normalized.startsWith('.') ? normalized : './' + normalized;
+}
+//# sourceMappingURL=import-sync-pattern.js.map

package/src/babel/import-sync-pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-sync-pattern.js","sourceRoot":"","sources":["import-sync-pattern.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as Babel from '@babel/core';\nimport type { types as t } from '@babel/core';\n\ntype Types = typeof Babel.types;\n\n/*\n  Support for `importSync` with a dynamic path, like:\n\n     importSync(`../components/results/${type}-result`)\n\n  In eager mode we can't do a truly dynamic import, so we expand the call into a\n  lookup table over the real contents of the directory. To do that correctly we\n  need to understand the *whole* pattern, not just the part before the first\n  interpolation.\n*/\n\nexport type PatternPart = { type: 'static'; value: string } | { type: 'dynamic'; value: t.Expression };\n\n// A parsed `importSync` specifier: the statically-known directory that we will\n// read, plus the pattern that filenames within it must match.\nexport interface ParsedSpecifier {\n  // always ends in \"/\", always starts with \".\" (we only support relative paths)\n  dir: string;\n  // the filename pattern, with the file extension (if any) already removed, so\n  // it lines up with the extension-less keys we put in the lookup table\n  pattern: PatternPart[];\n}\n\n// Turns a specifier expression into a flat list of static and dynamic parts.\n// Returns undefined if this isn't a shape we understand.\nexport function patternParts(types: Types, specifier: t.Node): PatternPart[] | undefined {\n  if (specifier.type === 'TemplateLiteral') {\n    let parts: PatternPart[] = [];\n    for (let [index, quasi] of specifier.quasis.entries()) {\n      parts.push({ type: 'static', value: quasi.value.cooked! });\n      let expression = specifier.expressions[index];\n      if (expression) {\n        if (!types.isExpression(expression)) {\n          return undefined;\n        }\n        parts.push({ type: 'dynamic', value: expression });\n      }\n    }\n    return normalize(parts);\n  }\n\n  // babel might transform the template form `../my-path/${id}` into\n  // '../my-path/'.concat(id)\n  if (\n    specifier.type === 'CallExpression' &&\n    specifier.callee.type === 'MemberExpression' &&\n    specifier.callee.property.type === 'Identifier' &&\n    specifier.callee.property.name === 'concat' &&\n    specifier.callee.object.type === 'StringLiteral'\n  ) {\n    let parts: PatternPart[] = [{ type: 'static', value: specifier.callee.object.value }];\n    for (let arg of specifier.arguments) {\n      if (arg.type === 'StringLiteral') {\n        parts.push({ type: 'static', value: arg.value });\n      } else if (types.isExpression(arg)) {\n        parts.push({ type: 'dynamic', value: arg });\n      } else {\n        return undefined;\n      }\n    }\n    return normalize(parts);\n  }\n\n  return undefined;\n}\n\n// merges adjacent static parts and drops empty ones, so that the rest of the\n// code can assume statics are maximal and non-empty\nfunction normalize(parts: PatternPart[]): PatternPart[] {\n  let output: PatternPart[] = [];\n  for (let part of parts) {\n    if (part.type === 'static') {\n      if (part.value === '') {\n        continue;\n      }\n      let previous = output[output.length - 1];\n      if (previous?.type === 'static') {\n        output[output.length - 1] = { type: 'static', value: previous.value + part.value };\n        continue;\n      }\n    }\n    output.push(part);\n  }\n  return output;\n}\n\n// Splits the parts into the directory we're going to read and the pattern that\n// entries in it need to match. Returns undefined when the parts don't describe\n// a relative path with a statically-known directory.\nexport function parseSpecifier(parts: PatternPart[]): ParsedSpecifier | undefined {\n  let first = parts[0];\n  if (first?.type !== 'static' || !first.value.startsWith('.')) {\n    return undefined;\n  }\n  let slash = first.value.lastIndexOf('/');\n  if (slash === -1) {\n    return undefined;\n  }\n  let dir = first.value.slice(0, slash + 1);\n  let head = first.value.slice(slash + 1);\n  let pattern = normalize([{ type: 'static', value: head }, ...parts.slice(1)]);\n\n  // The directory we read is only one level deep, so a \"/\" anywhere later in\n  // the pattern could never match one of its entries.\n  if (pattern.some(part => part.type === 'static' && part.value.includes('/'))) {\n    return undefined;\n  }\n\n  return { dir, pattern: withoutExtension(pattern) };\n}\n\n// The lookup table is keyed by extension-less filenames, because that's what we\n// hand to the resolver. So if the author wrote the extension (which is what\n// Vite's own dynamic import rules ask for) we drop it from the pattern too.\nfunction withoutExtension(pattern: PatternPart[]): PatternPart[] {\n  let last = pattern[pattern.length - 1];\n  if (last?.type !== 'static') {\n    return pattern;\n  }\n  let stripped = last.value.replace(/\\.\\w+$/, '');\n  if (stripped === last.value) {\n    return pattern;\n  }\n  return normalize([...pattern.slice(0, -1), { type: 'static', value: stripped }]);\n}\n\n// The key we use for a directory entry: its name minus the file extension.\nexport function entryKey(entry: string): string {\n  let dot = entry.lastIndexOf('.');\n  return dot === -1 ? entry : entry.slice(0, dot);\n}\n\n// Which keys could this pattern actually select? Everything else in the\n// directory would be dead weight in the bundle.\nexport function patternMatcher(pattern: PatternPart[]): (key: string) => boolean {\n  let source =\n    '^' + pattern.map(part => (part.type === 'static' ? escapeRegExp(part.value) : '[\\\\s\\\\S]*')).join('') + '$';\n  let regex = new RegExp(source);\n  return key => regex.test(key);\n}\n\nfunction escapeRegExp(str: string): string {\n  return str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n\n// Builds the expression we use to index into the lookup table. When the pattern\n// is a single interpolation (the only shape that used to work) this is just that\n// expression, so existing call sites compile to byte-identical output.\nexport function lookupExpression(types: Types, pattern: PatternPart[]): t.Expression {\n  if (pattern.length === 1 && pattern[0].type === 'dynamic') {\n    return pattern[0].value;\n  }\n  let quasis: t.TemplateElement[] = [];\n  let expressions: t.Expression[] = [];\n  let pending = '';\n  for (let part of pattern) {\n    if (part.type === 'static') {\n      pending += part.value;\n    } else {\n      quasis.push(types.templateElement({ raw: escapeTemplate(pending), cooked: pending }));\n      pending = '';\n      expressions.push(part.value);\n    }\n  }\n  quasis.push(types.templateElement({ raw: escapeTemplate(pending), cooked: pending }, true));\n  return types.templateLiteral(quasis, expressions);\n}\n\nfunction escapeTemplate(str: string): string {\n  return str.replace(/\\\\/g, '\\\\\\\\').replace(/`/g, '\\\\`').replace(/\\$\\{/g, '\\\\${');\n}\n\n// path.join() will strip a leading \"./\", which would turn our relative path\n// into a bare package specifier.\nexport function relativeSpecifier(path: string): string {\n  let normalized = path.replace(/\\\\/g, '/');\n  return normalized.startsWith('.') ? normalized : './' + normalized;\n}\n"]}

package/src/babel/macro-condition.d.ts

@@ -0,0 +1,12 @@
+import type { NodePath } from '@babel/traverse';
+import type { types as t } from '@babel/core';
+import type * as Babel from '@babel/core';
+import type State from './state';
+export interface MacroCondition {
+    parity: boolean;
+    conditional: NodePath<t.IfStatement | t.ConditionalExpression | t.LogicalExpression>;
+    callExpression: NodePath<t.CallExpression>;
+}
+export declare function identifyMacroConditionPath(path: NodePath<t.IfStatement | t.ConditionalExpression | t.LogicalExpression>): MacroCondition | false;
+export default function macroCondition(macro: MacroCondition, state: State, context: typeof Babel): void;
+//# sourceMappingURL=macro-condition.d.ts.map

package/src/babel/macro-condition.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identifyMacroConditionPath = identifyMacroConditionPath;
+exports.default = macroCondition;
+const evaluate_json_1 = require("./evaluate-json");
+const error_1 = __importDefault(require("./error"));
+function identifyMacroConditionPath(path) {
+    let parity = true;
+    let test;
+    if (path.isLogicalExpression()) {
+        if (path.node.operator !== '&&' && path.node.operator !== '||') {
+            return false;
+        }
+        test = path.get('left');
+    }
+    else {
+        test = path.get('test');
+    }
+    if (test.isUnaryExpression() && test.node.operator === '!') {
+        parity = false;
+        test = test.get('argument');
+    }
+    if (test.isCallExpression()) {
+        let callee = test.get('callee');
+        if (callee.referencesImport('@embroider/macros', 'macroCondition')) {
+            return { parity, conditional: path, callExpression: test };
+        }
+    }
+    return false;
+}
+function macroCondition(macro, state, context) {
+    let args = macro.callExpression.get('arguments');
+    if (args.length !== 1) {
+        throw (0, error_1.default)(macro.conditional, `macroCondition accepts exactly one argument, you passed ${args.length}`);
+    }
+    let [predicatePath] = args;
+    let predicate = new evaluate_json_1.Evaluator({ state }).evaluate(predicatePath);
+    if (!predicate.confident) {
+        throw (0, error_1.default)(args[0], `the first argument to macroCondition must be statically known`);
+    }
+    if (state.opts.mode === 'run-time' && predicate.hasRuntimeImplementation !== false) {
+        let callee = macro.callExpression.get('callee');
+        callee.replaceWith(state.importUtil.import(callee, state.pathToOurAddon('runtime'), 'macroCondition'));
+        return;
+    }
+    if (macro.conditional.isLogicalExpression()) {
+        let effectivePredicate = predicate.value === macro.parity;
+        let right = macro.conditional.get('right');
+        let keptRight = (macro.conditional.node.operator === '&&') === effectivePredicate;
+        if (keptRight) {
+            macro.conditional.replaceWith(right.node);
+        }
+        else {
+            state.removed.add(right.node);
+            macro.conditional.replaceWith(context.types.booleanLiteral(effectivePredicate));
+        }
+        return;
+    }
+    let conditional = macro.conditional;
+    let consequent = conditional.get('consequent');
+    let alternate = conditional.get('alternate');
+    let [kept, removed] = predicate.value === macro.parity ? [consequent.node, alternate.node] : [alternate.node, consequent.node];
+    if (kept) {
+        conditional.replaceWith(kept);
+    }
+    else {
+        conditional.remove();
+    }
+    if (removed) {
+        state.removed.add(removed);
+    }
+}
+//# sourceMappingURL=macro-condition.js.map

package/src/babel/macro-condition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"macro-condition.js","sourceRoot":"","sources":["macro-condition.ts"],"names":[],"mappings":"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","sourcesContent":["import type { NodePath } from '@babel/traverse';\nimport { Evaluator } from './evaluate-json';\nimport type { types as t } from '@babel/core';\nimport type * as Babel from '@babel/core';\nimport error from './error';\nimport type State from './state';\n\nexport interface MacroCondition {\n  parity: boolean;\n  conditional: NodePath<t.IfStatement | t.ConditionalExpression | t.LogicalExpression>;\n  callExpression: NodePath<t.CallExpression>;\n}\n\nexport function identifyMacroConditionPath(\n  path: NodePath<t.IfStatement | t.ConditionalExpression | t.LogicalExpression>\n): MacroCondition | false {\n  let parity = true;\n  let test: NodePath<t.Node>;\n\n  if (path.isLogicalExpression()) {\n    if (path.node.operator !== '&&' && path.node.operator !== '||') {\n      return false;\n    }\n    test = path.get('left');\n  } else {\n    test = (path as NodePath<t.IfStatement | t.ConditionalExpression>).get('test');\n  }\n\n  if (test.isUnaryExpression() && test.node.operator === '!') {\n    parity = false;\n    test = test.get('argument');\n  }\n\n  if (test.isCallExpression()) {\n    let callee = test.get('callee');\n    if (callee.referencesImport('@embroider/macros', 'macroCondition')) {\n      return { parity, conditional: path, callExpression: test };\n    }\n  }\n  return false;\n}\n\nexport default function macroCondition(macro: MacroCondition, state: State, context: typeof Babel) {\n  let args = macro.callExpression.get('arguments');\n  if (args.length !== 1) {\n    throw error(macro.conditional, `macroCondition accepts exactly one argument, you passed ${args.length}`);\n  }\n\n  let [predicatePath] = args;\n  let predicate = new Evaluator({ state }).evaluate(predicatePath);\n  if (!predicate.confident) {\n    throw error(args[0], `the first argument to macroCondition must be statically known`);\n  }\n\n  if (state.opts.mode === 'run-time' && predicate.hasRuntimeImplementation !== false) {\n    let callee = macro.callExpression.get('callee');\n    callee.replaceWith(state.importUtil.import(callee, state.pathToOurAddon('runtime'), 'macroCondition'));\n    return;\n  }\n\n  if (macro.conditional.isLogicalExpression()) {\n    let effectivePredicate = predicate.value === macro.parity;\n    let right = macro.conditional.get('right');\n    let keptRight = (macro.conditional.node.operator === '&&') === effectivePredicate;\n    if (keptRight) {\n      macro.conditional.replaceWith(right.node);\n    } else {\n      state.removed.add(right.node);\n      macro.conditional.replaceWith(context.types.booleanLiteral(effectivePredicate));\n    }\n    return;\n  }\n\n  let conditional = macro.conditional as NodePath<t.IfStatement | t.ConditionalExpression>;\n  let consequent = conditional.get('consequent');\n  let alternate = conditional.get('alternate');\n\n  let [kept, removed] =\n    predicate.value === macro.parity ? [consequent.node, alternate.node] : [alternate.node, consequent.node];\n  if (kept) {\n    conditional.replaceWith(kept);\n  } else {\n    conditional.remove();\n  }\n  if (removed) {\n    state.removed.add(removed);\n  }\n}\n"]}

package/src/babel/macros-babel-plugin.d.ts

@@ -0,0 +1,3 @@
+import type * as Babel from '@babel/core';
+export default function main(context: typeof Babel): unknown;
+//# sourceMappingURL=macros-babel-plugin.d.ts.map

package/src/babel/macros-babel-plugin.js

@@ -0,0 +1,312 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = main;
+const state_1 = require("./state");
+const get_config_1 = require("./get-config");
+const macro_condition_1 = __importStar(require("./macro-condition"));
+const each_1 = require("./each");
+const error_1 = __importDefault(require("./error"));
+const fail_build_1 = __importDefault(require("./fail-build"));
+const evaluate_json_1 = require("./evaluate-json");
+const fs_1 = require("fs");
+const import_sync_pattern_1 = require("./import-sync-pattern");
+const path_1 = require("path");
+function main(context) {
+    let t = context.types;
+    let visitor = {
+        Program: {
+            enter(path, state) {
+                (0, state_1.initState)(context, path, state);
+            },
+            exit(_, state) {
+                // @embroider/macros itself has no runtime behaviors and should always be removed
+                state.importUtil.removeAllImports('@embroider/macros');
+                for (let handler of state.jobs) {
+                    handler();
+                }
+            },
+        },
+        'IfStatement|ConditionalExpression|LogicalExpression': {
+            enter(path, state) {
+                let found = (0, macro_condition_1.identifyMacroConditionPath)(path);
+                if (found) {
+                    state.calledIdentifiers.add(found.callExpression.get('callee').node);
+                    (0, macro_condition_1.default)(found, state, context);
+                }
+            },
+        },
+        ForOfStatement: {
+            enter(path, state) {
+                if ((0, each_1.isEachPath)(path)) {
+                    state.calledIdentifiers.add(path.get('right').get('callee').node);
+                    (0, each_1.insertEach)(path, state, context);
+                }
+            },
+        },
+        FunctionDeclaration: {
+            enter(path, state) {
+                let id = path.get('id');
+                if (id.isIdentifier() && id.node.name === 'initializeRuntimeMacrosConfig' && state.opts.mode === 'run-time') {
+                    let pkg = state.owningPackage();
+                    if (pkg && pkg.name === '@embroider/macros') {
+                        (0, get_config_1.inlineRuntimeConfig)(path, state, context);
+                    }
+                }
+            },
+        },
+        CallExpression: {
+            enter(path, state) {
+                let callee = path.get('callee');
+                if (!callee.isIdentifier()) {
+                    return;
+                }
+                // failBuild is implemented for side-effect, not value, so it's not
+                // handled by evaluateMacroCall.
+                if (callee.referencesImport('@embroider/macros', 'failBuild')) {
+                    state.calledIdentifiers.add(callee.node);
+                    (0, fail_build_1.default)(path, state);
+                    return;
+                }
+                if (callee.referencesImport('@embroider/macros', 'importSync')) {
+                    // we handle importSync in the exit hook
+                    return;
+                }
+                // getOwnConfig/getGlobalConfig/getConfig needs special handling, so
+                // even though it also emits values via evaluateMacroCall when they're
+                // needed recursively by other macros, it has its own insertion-handling
+                // code that we invoke here.
+                //
+                // The things that are special include:
+                //  - automatic collapsing of chained properties, etc
+                //  - these macros have runtime implementations sometimes, which changes
+                //    how we rewrite them
+                let mode = callee.referencesImport('@embroider/macros', 'getOwnConfig')
+                    ? 'own'
+                    : callee.referencesImport('@embroider/macros', 'getGlobalConfig')
+                        ? 'getGlobalConfig'
+                        : callee.referencesImport('@embroider/macros', 'getConfig')
+                            ? 'package'
+                            : false;
+                if (mode) {
+                    state.calledIdentifiers.add(callee.node);
+                    (0, get_config_1.insertConfig)(path, state, mode, context);
+                    return;
+                }
+                // isTesting can have a runtime implementation. At compile time it
+                // instead falls through to evaluateMacroCall.
+                if (callee.referencesImport('@embroider/macros', 'isTesting') && state.opts.mode === 'run-time') {
+                    state.calledIdentifiers.add(callee.node);
+                    callee.replaceWith(state.importUtil.import(callee, state.pathToOurAddon('runtime'), 'isTesting'));
+                    return;
+                }
+                if (callee.referencesImport('@embroider/macros', 'setTesting')) {
+                    state.calledIdentifiers.add(callee.node);
+                    if (state.opts.mode === 'run-time') {
+                        callee.replaceWith(state.importUtil.import(callee, state.pathToOurAddon('runtime'), 'setTesting'));
+                    }
+                    else {
+                        let args = path.get('arguments');
+                        if (args.length === 0) {
+                            throw (0, error_1.default)(path, `setTesting() requires a boolean argument`);
+                        }
+                        let arg = args[0];
+                        let evaluator = new evaluate_json_1.Evaluator({ state });
+                        let result = evaluator.evaluate(arg);
+                        if (!result.confident) {
+                            throw (0, error_1.default)(arg, `setTesting() can only be called with a statically analyzable value in compile-time mode. The argument must be a literal boolean or other macro that can resolves to a boolean at compile-time.`);
+                        }
+                        let macrosConfig = state.opts.globalConfig['@embroider/macros'] || {};
+                        let currentIsTesting = Boolean(macrosConfig.isTesting);
+                        let newIsTesting = Boolean(result.value);
+                        if (currentIsTesting !== newIsTesting) {
+                            throw (0, error_1.default)(path, `setTesting(${newIsTesting}) cannot change the testing state in compile-time mode. The current global config has isTesting=${currentIsTesting}. ` +
+                                `setTesting() calls are compiled away at build time, so they cannot change the testing state. ` +
+                                `If you need to change the testing state at runtime, use runtime mode instead.`);
+                        }
+                        path.remove();
+                    }
+                    return;
+                }
+                let result = new evaluate_json_1.Evaluator({ state }).evaluateMacroCall(path);
+                if (result.confident) {
+                    state.calledIdentifiers.add(callee.node);
+                    path.replaceWith((0, evaluate_json_1.buildLiterals)(result.value, context));
+                }
+            },
+            exit(path, state) {
+                let callee = path.get('callee');
+                if (!callee.isIdentifier()) {
+                    return;
+                }
+                // importSync doesn't evaluate to a static value, so it's implemented
+                // directly here, not in evaluateMacroCall.
+                // We intentionally do this on exit here, to allow other transforms to handle importSync before we do
+                // For example ember-auto-import needs to do some custom transforms to enable use of dynamic template strings,
+                // so its babel plugin needs to see and handle the importSync call first!
+                if (callee.referencesImport('@embroider/macros', 'importSync')) {
+                    if (state.opts.importSyncImplementation === 'eager') {
+                        let specifier = path.node.arguments[0];
+                        let target;
+                        if ((specifier === null || specifier === void 0 ? void 0 : specifier.type) === 'StringLiteral') {
+                            target = specifier.value;
+                        }
+                        else {
+                            let parts = specifier ? (0, import_sync_pattern_1.patternParts)(t, specifier) : undefined;
+                            if (parts && parts.length > 0 && parts.every(part => part.type === 'static')) {
+                                // a template literal that has no interpolations at all is just
+                                // a string, so treat it like one
+                                target = parts.map(part => (part.type === 'static' ? part.value : '')).join('');
+                            }
+                            else {
+                                let parsed = parts ? (0, import_sync_pattern_1.parseSpecifier)(parts) : undefined;
+                                if (!parsed) {
+                                    throw new Error(`importSync eager mode only supports dynamic paths which are relative, must start with a '.', had ${specifier === null || specifier === void 0 ? void 0 : specifier.type}`);
+                                }
+                                const { dir, pattern } = parsed;
+                                const resolvedPath = (0, path_1.resolve)((0, path_1.dirname)(state.filename), dir);
+                                let entries = [];
+                                if ((0, fs_1.existsSync)(resolvedPath)) {
+                                    entries = (0, fs_1.readdirSync)(resolvedPath).filter(e => !e.startsWith('.'));
+                                }
+                                const matches = (0, import_sync_pattern_1.patternMatcher)(pattern);
+                                const seen = new Set();
+                                const properties = [];
+                                for (const entry of entries) {
+                                    const key = (0, import_sync_pattern_1.entryKey)(entry);
+                                    // entries that the pattern could never select would just bloat
+                                    // the bundle, and files that differ only by extension collapse
+                                    // to the same key (and the same extension-less import)
+                                    if (!matches(key) || seen.has(key)) {
+                                        continue;
+                                    }
+                                    seen.add(key);
+                                    const id = t.callExpression(state.importUtil.import(path, state.pathToOurAddon('es-compat2'), 'default', 'esc'), [state.importUtil.import(path, (0, import_sync_pattern_1.relativeSpecifier)((0, path_1.join)(dir, key)), '*')]);
+                                    properties.push(t.objectProperty(t.stringLiteral(key), id));
+                                }
+                                const memberExpr = t.memberExpression(t.objectExpression(properties), (0, import_sync_pattern_1.lookupExpression)(t, pattern), true);
+                                path.replaceWith(memberExpr);
+                                state.calledIdentifiers.add(callee.node);
+                                return;
+                            }
+                        }
+                        path.replaceWith(t.callExpression(state.importUtil.import(path, state.pathToOurAddon('es-compat2'), 'default', 'esc'), [
+                            state.importUtil.import(path, target, '*'),
+                        ]));
+                        state.calledIdentifiers.add(callee.node);
+                        return;
+                    }
+                    else {
+                        if (path.scope.hasBinding('require')) {
+                            path.scope.rename('require');
+                        }
+                        let r = t.identifier('require');
+                        state.generatedRequires.add(r);
+                        path.replaceWith(t.callExpression(state.importUtil.import(path, state.pathToOurAddon('es-compat2'), 'default', 'esc'), [
+                            t.callExpression(r, path.node.arguments),
+                        ]));
+                    }
+                }
+            },
+        },
+        ReferencedIdentifier(path, state) {
+            for (let candidate of [
+                'dependencySatisfies',
+                'appEmberSatisfies',
+                'moduleExists',
+                'getConfig',
+                'getOwnConfig',
+                'failBuild',
+                // we cannot check importSync, as the babel transform runs on exit, so *after* this check
+                // 'importSync',
+                'isDevelopingApp',
+                'isDevelopingThisPackage',
+                'isTesting',
+                'setTesting',
+            ]) {
+                if (path.referencesImport('@embroider/macros', candidate) && !state.calledIdentifiers.has(path.node)) {
+                    throw (0, error_1.default)(path, `You can only use ${candidate} as a function call`);
+                }
+            }
+            if (path.referencesImport('@embroider/macros', 'macroCondition') && !state.calledIdentifiers.has(path.node)) {
+                throw (0, error_1.default)(path, `macroCondition can only be used as the predicate of an if statement, ternary expression, or && / || logical expression`);
+            }
+            if (path.referencesImport('@embroider/macros', 'each') && !state.calledIdentifiers.has(path.node)) {
+                throw (0, error_1.default)(path, `the each() macro can only be used within a for ... of statement, like: for (let x of each(thing)){}`);
+            }
+            if (state.opts.owningPackageRoot) {
+                // there is only an owningPackageRoot when we are running inside a
+                // classic ember-cli build. In the embroider stage3 build, there is no
+                // owning package root because we're compiling *all* packages
+                // simultaneously.
+                //
+                // given that we're inside classic ember-cli, stop here without trying
+                // to rewrite bare `require`. It's not needed, because both our
+                // `importSync` and any user-written bare `require` can both mean the
+                // same thing: runtime AMD `require`.
+                return;
+            }
+            if (path.node.name === 'require' &&
+                !state.generatedRequires.has(path.node) &&
+                !path.scope.hasBinding('require') &&
+                state.owningPackage().isEmberAddon()) {
+                // Our importSync macro has been compiled to `require`. But we want to
+                // distinguish that from any pre-existing, user-written `require` in an
+                // Ember addon, which should retain its *runtime* meaning.
+                path.replaceWith(t.memberExpression(t.identifier('window'), path.node));
+            }
+        },
+    };
+    if (context.types.OptionalMemberExpression) {
+        // our getConfig and getOwnConfig macros are supposed to be able to absorb
+        // optional chaining. To make that work we need to see the optional chaining
+        // before preset-env compiles them away.
+        visitor.OptionalMemberExpression = {
+            enter(path, state) {
+                if (state.opts.mode === 'compile-time') {
+                    let result = new evaluate_json_1.Evaluator({ state }).evaluate(path);
+                    if (result.confident) {
+                        path.replaceWith((0, evaluate_json_1.buildLiterals)(result.value, context));
+                    }
+                }
+            },
+        };
+    }
+    return { visitor };
+}
+//# sourceMappingURL=macros-babel-plugin.js.map