@atlaspack/babel-plugin-transform-contextual-imports 2.14.2-noselfbuild-8c516162e.0 → 2.14.2-noselfbuild-b8f24f3f8.0

package/lib/index.js

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const {
+  declare
+} = require('@babel/helper-plugin-utils');
+const isServer = opts => {
+  return 'server' in opts && opts.server;
+};
+const isNode = opts => !!('node' in opts && opts.node);
+var _default = exports.default = declare(api => {
+  const {
+    types: t
+  } = api;
+  const isImportCondCallExpression = node => {
+    if (node.type === 'CallExpression' && node.callee.type === 'Identifier' && node.callee.name === 'importCond') {
+      if (node.arguments.length === 3 && node.arguments.every(arg => arg.type === 'StringLiteral')) {
+        return true;
+      } else {
+        // Simple error for incorrect syntax (since it's documented with the type)
+        throw new Error('importCond must have three string literal arguments');
+      }
+    }
+    return false;
+  };
+  const buildCondFunction = (cond, ifTrue, ifFalse) => t.conditionalExpression(t.logicalExpression('&&', t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), t.callExpression(t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), [cond])), t.memberExpression(t.callExpression(t.identifier('require'), [ifTrue]), t.identifier('default')), t.memberExpression(t.callExpression(t.identifier('require'), [ifFalse]), t.identifier('default')));
+  const buildNodeObject = (identifier, cond, ifTrue, ifFalse) => [
+  // Create object containing imports
+  t.variableDeclaration('const', [t.variableDeclarator(identifier, t.objectExpression([t.objectProperty(t.identifier('ifTrue'), t.memberExpression(t.callExpression(t.identifier('require'), [ifTrue]), t.identifier('default'))), t.objectProperty(t.identifier('ifFalse'), t.memberExpression(t.callExpression(t.identifier('require'), [ifFalse]), t.identifier('default')))]))]),
+  // Create lazy getter via the load property on the object.
+  // This is node module resolution safe because each time the import is accessed, we re-evaluate the condition.
+  t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('Object'), t.identifier('defineProperty')), [identifier, t.stringLiteral('load'), t.objectExpression([t.objectProperty(t.identifier('get'), t.arrowFunctionExpression([], t.conditionalExpression(t.logicalExpression('&&', t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), t.callExpression(t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), [cond])), t.memberExpression(identifier, t.identifier('ifTrue')), t.memberExpression(identifier, t.identifier('ifFalse')))))])]))];
+  const buildServerObject = (identUid, cond, ifTrue, ifFalse) => [
+  // Create object containing imports
+  t.variableDeclaration('const', [t.variableDeclarator(t.identifier(identUid), t.objectExpression([t.objectProperty(t.identifier('ifTrue'), t.memberExpression(t.callExpression(t.identifier('require'), [ifTrue]), t.identifier('default'))), t.objectProperty(t.identifier('ifFalse'), t.memberExpression(t.callExpression(t.identifier('require'), [ifFalse]), t.identifier('default')))]))]),
+  // Create lazy getter via the load property on the object
+  t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('Object'), t.identifier('defineProperty')), [t.identifier(identUid), t.stringLiteral('load'), t.objectExpression([t.objectProperty(t.identifier('get'), t.arrowFunctionExpression([], t.conditionalExpression(t.logicalExpression('&&', t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), t.callExpression(t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), [cond])), t.memberExpression(t.identifier(identUid), t.identifier('ifTrue')), t.memberExpression(t.identifier(identUid), t.identifier('ifFalse')))))])]))];
+  const checkIsServer = (path, state) => {
+    if (path.node.callee.type === 'Identifier' && path.node.callee.name === 'importCond') {
+      if (path.node.arguments.length == 3 && path.node.arguments.every(arg => arg.type === 'StringLiteral')) {
+        const [cond, ifTrue, ifFalse] = path.node.arguments;
+        if (isServer(state.opts)) {
+          // Make module pass lazy in ssr
+          const identUid = path.scope.generateUid(`${cond.value}$${ifTrue.value}$${ifFalse.value}`);
+          state.importNodes ??= [];
+          state.importNodes.push(...buildServerObject(identUid, cond, ifTrue, ifFalse));
+
+          // Replace call expression with reference to lazy object getter
+          path.replaceWith(t.memberExpression(t.identifier(identUid), t.identifier('load')));
+        }
+      }
+    }
+  };
+  return {
+    name: '@atlaspack/babel-plugin-transform-contextual-imports',
+    visitor: {
+      CallExpression: {
+        enter(path, state) {
+          // Preserve server behaviour in deletable code
+          checkIsServer(path, state);
+          const node = path.node;
+          if (isImportCondCallExpression(node)) {
+            const [cond, ifTrue, ifFalse] = node.arguments;
+            if (!isNode(state.opts)) {
+              // Replace the importCond call with a conditional require import, as a fallback for environments that don't support Atlaspack
+              path.replaceWith(buildCondFunction(cond, ifTrue, ifFalse));
+            }
+          }
+        }
+      },
+      VariableDeclaration: {
+        enter(path, state) {
+          if (isNode(state.opts)) {
+            if (path.node.declarations.length === 1 && path.node.declarations[0].type === 'VariableDeclarator' && path.node.declarations[0].id.type === 'Identifier') {
+              var _state$visitedIdentif;
+              const importId = path.node.declarations[0].id;
+              const call = path.node.declarations[0].init;
+
+              // Mark identifier for object so we don't add the load property to it
+              (_state$visitedIdentif = state.visitedIdentifiers) === null || _state$visitedIdentif === void 0 || _state$visitedIdentif.add(importId);
+              if (call && isImportCondCallExpression(call)) {
+                var _state$conditionalImp;
+                const [cond, ifTrue, ifFalse] = call.arguments;
+
+                // Replace with object containing imports and lazy getter, which allows us to load the correct import based on the condition at runtime
+                path.replaceWithMultiple(buildNodeObject(importId, cond, ifTrue, ifFalse));
+
+                // Add identifier name to set so we can mutate all import usages in the exit pass
+                (_state$conditionalImp = state.conditionalImportIdentifiers) === null || _state$conditionalImp === void 0 || _state$conditionalImp.add(importId.name);
+              }
+            }
+          }
+        }
+      },
+      Identifier: {
+        exit(path, state) {
+          var _state$conditionalImp2, _state$visitedIdentif2;
+          const identifier = (_state$conditionalImp2 = state.conditionalImportIdentifiers) === null || _state$conditionalImp2 === void 0 ? void 0 : _state$conditionalImp2.has(path.node.name);
+          if (identifier && !((_state$visitedIdentif2 = state.visitedIdentifiers) !== null && _state$visitedIdentif2 !== void 0 && _state$visitedIdentif2.has(path.node))) {
+            var _state$visitedIdentif3;
+            // Add load property to the import usage
+            const newIdentifer = t.identifier(path.node.name);
+            path.replaceWith(t.memberExpression(newIdentifer, t.identifier('load')));
+            (_state$visitedIdentif3 = state.visitedIdentifiers) === null || _state$visitedIdentif3 === void 0 || _state$visitedIdentif3.add(newIdentifer);
+          }
+        }
+      },
+      Program: {
+        enter(_, state) {
+          state.conditionalImportIdentifiers = new Set();
+          state.visitedIdentifiers = new Set();
+        },
+        exit(path, state) {
+          if (state.importNodes) {
+            // If there's an import node, add it to the top of the body
+            path.unshiftContainer('body', state.importNodes);
+          }
+        }
+      }
+    }
+  };
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/babel-plugin-transform-contextual-imports",
-  "version": "2.14.2-noselfbuild-8c516162e.0",
+  "version": "2.14.2-noselfbuild-b8f24f3f8.0",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -23,5 +23,5 @@
     "@types/babel__helper-plugin-utils": "^7.10.3"
   },
   "type": "commonjs",
-  "gitHead": "8c516162e3109bbebe535130a7de57e9e59a4eb8"
+  "gitHead": "b8f24f3f82b06cb57291e1fa02e9655350bb1ac2"
 }

package/src/{index.ts → index.js}

@@ -1,43 +1,15 @@
-import type {PluginObj, NodePath, types as BabelTypes} from '@babel/core';
-import {declare} from '@babel/helper-plugin-utils';
+const {declare} = require('@babel/helper-plugin-utils');
 
-interface Opts {
-  /** @deprecated Use "node" instead */
-  server?: boolean;
-  /** Use node safe import cond syntax */
-  node?: boolean;
-}
-
-interface State {
-  /** Plugin options */
-  opts: Opts;
-  /** @deprecated Statement types didn't work so using any */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  importNodes?: any[];
-  /** Set of identifier names that need to be mutated after import was transformed */
-  conditionalImportIdentifiers?: Set<string>;
-  /** Set of identifiers that have been visited in the exit pass, to avoid adding the load property multiple times */
-  visitedIdentifiers?: Set<BabelTypes.Identifier>;
-}
-
-const isServer = (opts: Opts) => {
+const isServer = (opts) => {
   return 'server' in opts && opts.server;
 };
 
-const isNode = (opts: Opts): boolean => !!('node' in opts && opts.node);
+const isNode = (opts) => !!('node' in opts && opts.node);
 
-export default declare((api): PluginObj<State> => {
+export default declare((api) => {
   const {types: t} = api;
 
-  const isImportCondCallExpression = (
-    node: BabelTypes.Node,
-  ): node is BabelTypes.CallExpression & {
-    arguments: [
-      BabelTypes.StringLiteral,
-      BabelTypes.StringLiteral,
-      BabelTypes.StringLiteral,
-    ];
-  } => {
+  const isImportCondCallExpression = (node) => {
     if (
       node.type === 'CallExpression' &&
       node.callee.type === 'Identifier' &&
@@ -45,10 +17,7 @@ export default declare((api): PluginObj<State> => {
     ) {
       if (
         node.arguments.length === 3 &&
-        node.arguments.every(
-          (arg): arg is BabelTypes.StringLiteral =>
-            arg.type === 'StringLiteral',
-        )
+        node.arguments.every((arg) => arg.type === 'StringLiteral')
       ) {
         return true;
       } else {
@@ -60,11 +29,7 @@ export default declare((api): PluginObj<State> => {
     return false;
   };
 
-  const buildCondFunction = (
-    cond: BabelTypes.StringLiteral,
-    ifTrue: BabelTypes.StringLiteral,
-    ifFalse: BabelTypes.StringLiteral,
-  ) =>
+  const buildCondFunction = (cond, ifTrue, ifFalse) =>
     t.conditionalExpression(
       t.logicalExpression(
         '&&',
@@ -87,12 +52,7 @@ export default declare((api): PluginObj<State> => {
       ),
     );
 
-  const buildNodeObject = (
-    identifier: BabelTypes.Identifier,
-    cond: BabelTypes.StringLiteral,
-    ifTrue: BabelTypes.StringLiteral,
-    ifFalse: BabelTypes.StringLiteral,
-  ) => [
+  const buildNodeObject = (identifier, cond, ifTrue, ifFalse) => [
     // Create object containing imports
     t.variableDeclaration('const', [
       t.variableDeclarator(
@@ -158,12 +118,7 @@ export default declare((api): PluginObj<State> => {
     ),
   ];
 
-  const buildServerObject = (
-    identUid: string,
-    cond: BabelTypes.StringLiteral,
-    ifTrue: BabelTypes.StringLiteral,
-    ifFalse: BabelTypes.StringLiteral,
-  ) => [
+  const buildServerObject = (identUid, cond, ifTrue, ifFalse) => [
     // Create object containing imports
     t.variableDeclaration('const', [
       t.variableDeclarator(
@@ -234,10 +189,7 @@ export default declare((api): PluginObj<State> => {
     ),
   ];
 
-  const checkIsServer = (
-    path: NodePath<BabelTypes.CallExpression>,
-    state: State,
-  ) => {
+  const checkIsServer = (path, state) => {
     if (
       path.node.callee.type === 'Identifier' &&
       path.node.callee.name === 'importCond'

package/test/babel-plugin-transform-contextual-imports.test.js

@@ -1,7 +1,5 @@
-// @flow
-
-import * as babel from '@babel/core';
-import assert from 'assert';
+const babel = require('@babel/core');
+const assert = require('assert');
 
 const plugin = require.resolve('../src/index.ts');