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

package/lib/index.d.ts

@@ -0,0 +1,19 @@
+import type { PluginObj, types as BabelTypes } from '@babel/core';
+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 */
+    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>;
+}
+declare const _default: (api: object, options: Record<string, any> | null | undefined, dirname: string) => PluginObj<State>;
+export default _default;

package/lib/index.js

@@ -0,0 +1,289 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return _default;
+  },
+});
+const _helperpluginutils = require('@babel/helper-plugin-utils');
+const isServer = (opts) => {
+  return 'server' in opts && opts.server;
+};
+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')),
+                ),
+              ),
+            ),
+          ]),
+        ],
+      ),
+    ),
+  ];
+  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'
+            ) {
+              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();
+        },
+        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/lib/index.mjs

@@ -0,0 +1,279 @@
+import {declare} from '@babel/helper-plugin-utils';
+const isServer = (opts) => {
+  return 'server' in opts && opts.server;
+};
+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')),
+                ),
+              ),
+            ),
+          ]),
+        ],
+      ),
+    ),
+  ];
+  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'
+            ) {
+              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();
+        },
+        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,7 +1,8 @@
 {
   "name": "@atlaspack/babel-plugin-transform-contextual-imports",
-  "version": "2.14.2-noselfbuild-8c516162e.0",
+  "version": "2.14.2-noselfbuild-71fe9e998.0",
   "license": "(MIT OR Apache-2.0)",
+  "type": "commonjs",
   "publishConfig": {
     "access": "public"
   },
@@ -9,11 +10,27 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "./lib/index.js",
-  "source": "./src/index.ts",
+  "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",
+      "require": "./lib/index.js",
+      "default": "./lib/index.js"
+    },
+    "./*": "./*"
+  },
   "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"
@@ -22,6 +39,5 @@
     "@types/babel__core": "^7.12.2",
     "@types/babel__helper-plugin-utils": "^7.10.3"
   },
-  "type": "commonjs",
-  "gitHead": "8c516162e3109bbebe535130a7de57e9e59a4eb8"
+  "gitHead": "71fe9e998256a417234fd5f388a7428aa0d6fd60"
 }

package/tsconfig.json

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