@atlaspack/babel-plugin-transform-contextual-imports 2.14.2-noselfbuild-8163359c1.0 → 2.14.2-noselfbuild-63bde801d.0

package/lib/index.js

@@ -1,110 +1,97 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
+exports.default = void 0;
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+  _helperPluginUtils = function () {
+    return data;
+  };
+  return data;
+}
+const isNode = opts => !!('node' in opts && opts.node);
+var _default = exports.default = (0, _helperPluginUtils().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');
+      }
     }
-});
-const _helperpluginutils = require("@babel/helper-plugin-utils");
-const isNode = (opts)=>!!('node' in opts && opts.node);
-const _default = (0, _helperpluginutils.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')))))])]))];
+  return {
+    name: '@atlaspack/babel-plugin-transform-contextual-imports',
+    visitor: {
+      CallExpression: {
+        enter(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));
             }
+          }
         }
-        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')))))
-                ])
-            ]))
-        ];
-    return {
-        name: '@atlaspack/babel-plugin-transform-contextual-imports',
-        visitor: {
-            CallExpression: {
-                enter (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') {
-                            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.visitedIdentifiers?.add(importId);
-                            if (call && isImportCondCallExpression(call)) {
-                                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.conditionalImportIdentifiers?.add(importId.name);
-                            }
-                        }
-                    }
-                }
-            },
-            Identifier: {
-                exit (path, state) {
-                    const identifier = state.conditionalImportIdentifiers?.has(path.node.name);
-                    if (identifier && !state.visitedIdentifiers?.has(path.node)) {
-                        // Add load property to the import usage
-                        const newIdentifer = t.identifier(path.node.name);
-                        path.replaceWith(t.memberExpression(newIdentifer, t.identifier('load')));
-                        state.visitedIdentifiers?.add(newIdentifer);
-                    }
-                }
-            },
-            Program: {
-                enter (_, state) {
-                    state.conditionalImportIdentifiers = new Set();
-                    state.visitedIdentifiers = new Set();
-                }
+      },
+      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();
+        }
+      }
+    }
+  };
+});

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@atlaspack/babel-plugin-transform-contextual-imports",
-  "version": "2.14.2-noselfbuild-8163359c1.0",
+  "version": "2.14.2-noselfbuild-63bde801d.0",
   "license": "(MIT OR Apache-2.0)",
-  "type": "module",
   "publishConfig": {
     "access": "public"
   },
@@ -10,28 +9,12 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/index.js",
-  "types": "lib/index.d.mts",
-  "exports": {
-    ".": {
-      "atlaspack::sources": "./src/index.mts",
-      "types": [
-        "./lib/index.d.mts",
-        "./src/index.mts"
-      ],
-      "import": "./lib/index.mjs",
-      "module-sync": "./lib/index.mjs",
-      "require": "./lib/index.js",
-      "default": "./lib/index.js"
-    },
-    "./*": "./*"
-  },
+  "main": "./lib/index.js",
+  "source": "./src/index.ts",
+  "types": "./src/index.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
-  "scripts": {
-    "build-tsc": "node ../../../scripts/build-tsc.mjs"
-  },
   "dependencies": {
     "@babel/core": "^7.12.2",
     "@babel/helper-plugin-utils": "^7.12.2"
@@ -40,5 +23,6 @@
     "@types/babel__core": "^7.12.2",
     "@types/babel__helper-plugin-utils": "^7.10.3"
   },
-  "gitHead": "8163359c1a8d316bfd4ca81f9f13f94bc5963fe9"
+  "type": "commonjs",
+  "gitHead": "63bde801db96c5cb339ea9360cbcd0172a26cbba"
 }

package/test/{babel-plugin-transform-contextual-imports.test.mts → babel-plugin-transform-contextual-imports.test.js}

@@ -1,26 +1,20 @@
+// @flow
+
 import * as babel from '@babel/core';
 import assert from 'assert';
-import path from 'path';
-import url from 'url';
-
-const __dirname = path.dirname(url.fileURLToPath(import.meta.url))
 
-const plugin = path.normalize(path.join(__dirname, '..', 'src', 'index.mts'));
+const plugin = require.resolve('../src/index.ts');
 
 describe('@atlaspack/babel-plugin-transform-contextual-imports', () => {
   it('should transform importCond to inline requires', () => {
     const input = `
       const Imported = importCond('CONDITION', 'IF_TRUE', 'IF_FALSE');
     `;
-    const result = babel.transformSync(input, {
+    const {code: transformed} = babel.transformSync(input, {
       configFile: false,
       presets: [],
       plugins: [plugin],
     });
-    if (!result) {
-      throw new Error('Unable to produce result');
-    }
-    const {code: transformed} = result;
 
     assert.equal(
       transformed,
@@ -34,15 +28,11 @@ describe('@atlaspack/babel-plugin-transform-contextual-imports', () => {
 
       console.log(Imported, Imported.someProperty);
     `;
-    const result = babel.transformSync(input, {
+    const {code: transformed} = babel.transformSync(input, {
       configFile: false,
       presets: [],
       plugins: [[plugin, {node: true}]],
     });
-    if (!result) {
-      throw new Error('Unable to produce result');
-    }
-    const {code: transformed} = result;
 
     assert.equal(
       transformed,

package/tsconfig.json

@@ -1,4 +1,12 @@
 {
-  "extends": "../../../tsconfig.json",
-  "include": ["src"]
+  "compilerOptions": {
+    "target": "es2016",
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/*"],
+  "exclude": ["node_modules"]
 }

package/lib/index.d.mts

@@ -1,15 +0,0 @@
-import type { PluginObj, types as BabelTypes } from '@babel/core';
-interface Opts {
-    /** Use node safe import cond syntax */
-    node?: boolean;
-}
-interface State {
-    /** Plugin options */
-    opts: Opts;
-    /** 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>;
-}
-declare const _default: (api: object, options: Record<string, any> | null | undefined, dirname: string) => PluginObj<State>;
-export default _default;

package/lib/index.mjs

@@ -1,94 +0,0 @@
-import { declare } from '@babel/helper-plugin-utils';
-const isNode = (opts) => !!('node' in opts && opts.node);
-export 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'))))),
-            ]),
-        ])),
-    ];
-    return {
-        name: '@atlaspack/babel-plugin-transform-contextual-imports',
-        visitor: {
-            CallExpression: {
-                enter(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') {
-                            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.visitedIdentifiers?.add(importId);
-                            if (call && isImportCondCallExpression(call)) {
-                                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.conditionalImportIdentifiers?.add(importId.name);
-                            }
-                        }
-                    }
-                },
-            },
-            Identifier: {
-                exit(path, state) {
-                    const identifier = state.conditionalImportIdentifiers?.has(path.node.name);
-                    if (identifier && !state.visitedIdentifiers?.has(path.node)) {
-                        // Add load property to the import usage
-                        const newIdentifer = t.identifier(path.node.name);
-                        path.replaceWith(t.memberExpression(newIdentifer, t.identifier('load')));
-                        state.visitedIdentifiers?.add(newIdentifer);
-                    }
-                },
-            },
-            Program: {
-                enter(_, state) {
-                    state.conditionalImportIdentifiers = new Set();
-                    state.visitedIdentifiers = new Set();
-                },
-            },
-        },
-    };
-});

package/lib/package.json

@@ -1 +0,0 @@
-{ "type": "commonjs" }