creevey 0.9.0-beta.1 → 0.9.0-beta.10

package/lib/esm/server/index.js

@@ -0,0 +1,64 @@
+import cluster from 'cluster';
+import { readConfig, defaultBrowser } from './config';
+import { logger } from './logger'; // NOTE: Impure function, mutate config by adding gridUrl prop
+
+async function startWebdriverServer(config, options) {
+  if (config.useDocker) {
+    return (await import('./docker')).default(config, options.browser, async () => (await import('./selenium/selenoid')).startSelenoidContainer(config, options.debug));
+  } else {
+    return (await import('./selenium/selenoid')).startSelenoidStandalone(config, options.debug);
+  }
+}
+
+export default async function (options) {
+  const config = await readConfig(options);
+  const {
+    browser = defaultBrowser,
+    extract,
+    tests,
+    update,
+    webpack,
+    ui,
+    port
+  } = options;
+  if (!config) return; // NOTE: We don't need docker nor selenoid for webpack or update options
+
+  if (!(config.gridUrl || Object.values(config.browsers).every(({
+    gridUrl
+  }) => gridUrl)) && !extract && !webpack && !tests && !update) {
+    await startWebdriverServer(config, options);
+  }
+
+  switch (true) {
+    case Boolean(extract) || tests:
+      {
+        return (await import('./extract')).default(config, options);
+      }
+
+    case Boolean(update):
+      {
+        return (await import('./update')).default(config, typeof update == 'string' ? update : undefined);
+      }
+
+    case webpack:
+      {
+        logger.info('Starting Webpack Compiler');
+        return (await import('./loaders/webpack/compile')).default(config, options);
+      }
+
+    case cluster.isPrimary:
+      {
+        logger.info('Starting Master Process');
+        const resolveApi = (await import('./master/server')).default(config.reportDir, port, ui);
+        return (await import('./master')).default(config, options, resolveApi);
+      }
+
+    default:
+      {
+        logger.info(`Starting Worker for ${browser}`);
+        return (await import('./worker')).default(config, { ...options,
+          browser
+        });
+      }
+  }
+}

package/lib/esm/server/loaders/babel/creevey-plugin.js

@@ -0,0 +1,72 @@
+import path from 'path';
+import { commonVisitor, FileType, mdxVisitor, previewVisitor, storyVisitor } from './helpers';
+import { logger } from '../../logger';
+let lastStoryFile = null;
+const stories = new Set();
+const reexportedStories = new Map();
+export default function () {
+  return {
+    pre() {
+      const parents = this.opts.parents() ?? [];
+      const story = this.opts.story();
+      this.resourcePath = this.filename;
+      this.fileType = FileType.Invalid; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+      this.visitedTopPaths = new Set();
+      this.visitedBindings = new Set();
+      this.reexportedStories = reexportedStories;
+
+      if (story && this.filename.startsWith(story) || parents.find(parent => this.reexportedStories.has(parent))) {
+        this.fileType = FileType.Story;
+        this.isMDX = path.parse(this.filename).ext == '.mdx';
+        lastStoryFile = this.filename;
+        stories.add(this.filename);
+      } else if (this.filename.startsWith(this.opts.preview)) this.fileType = FileType.Preview;else if (lastStoryFile && this.opts.debug) {
+        logger.warn('Trying to transform possible non-story file', this.resourcePath, 'Please check the', lastStoryFile);
+        lastStoryFile = null; // TODO Add link to docs, how creevey works and what user should do in this situation
+      }
+    },
+
+    visitor: { ...commonVisitor,
+
+      ExportAllDeclaration(path) {
+        if (this.fileType == FileType.Story && typeof storyVisitor.ExportAllDeclaration == 'function') {
+          storyVisitor.ExportAllDeclaration.call(this, path, this);
+        }
+      },
+
+      ExportDefaultDeclaration(path) {
+        if (this.fileType == FileType.Story && typeof storyVisitor.ExportDefaultDeclaration == 'function') {
+          storyVisitor.ExportDefaultDeclaration.call(this, path, this);
+        }
+      },
+
+      ExportNamedDeclaration(path) {
+        if (this.fileType == FileType.Preview && typeof previewVisitor.ExportNamedDeclaration == 'function') {
+          previewVisitor.ExportNamedDeclaration.call(this, path, this);
+        }
+
+        if (this.fileType == FileType.Story && typeof storyVisitor.ExportNamedDeclaration == 'function') {
+          storyVisitor.ExportNamedDeclaration.call(this, path, this);
+        }
+      },
+
+      CallExpression(path) {
+        if (this.fileType == FileType.Preview && typeof previewVisitor.CallExpression == 'function') {
+          previewVisitor.CallExpression.call(this, path, this);
+        }
+
+        if (this.fileType == FileType.Story && typeof storyVisitor.CallExpression == 'function') {
+          storyVisitor.CallExpression.call(this, path, this);
+        }
+      },
+
+      FunctionDeclaration(path) {
+        if (this.isMDX && typeof mdxVisitor.FunctionDeclaration == 'function') {
+          mdxVisitor.FunctionDeclaration.call(this, path, this);
+        }
+      }
+
+    }
+  };
+}

package/lib/esm/server/loaders/babel/helpers.js

@@ -0,0 +1,452 @@
+import * as t from '@babel/types';
+import { isDefined } from '../../../types';
+
+function isExports(path) {
+  const {
+    parentPath
+  } = path;
+  return path.node.name == 'exports' && path.scope.hasGlobal('exports') && !path.scope.hasBinding('exports') && parentPath.isMemberExpression() && parentPath.get('object').isIdentifier({
+    name: 'exports'
+  });
+}
+
+function isModuleExports(path) {
+  const {
+    parentPath
+  } = path;
+  return path.node.name == 'module' && path.scope.hasGlobal('module') && !path.scope.hasBinding('module') && parentPath.isMemberExpression() && parentPath.get('object').isIdentifier({
+    name: 'module'
+  }) && parentPath.get('property').isIdentifier({
+    name: 'exports'
+  });
+}
+
+function isObjectAssign(path) {
+  if (!(path !== null && path !== void 0 && path.isCallExpression())) return false;
+  const calleePath = path.get('callee');
+  return calleePath.isMemberExpression() && calleePath.get('object').isIdentifier({
+    name: 'Object'
+  }) && calleePath.get('property').isIdentifier({
+    name: 'assign'
+  });
+}
+
+function isTemplateBind(path) {
+  if (!(path !== null && path !== void 0 && path.isCallExpression())) return false;
+  const calleePath = path.get('callee');
+  return calleePath.isMemberExpression() && calleePath.get('object').isIdentifier() && calleePath.get('property').isIdentifier({
+    name: 'bind'
+  });
+}
+
+function findRootPath(path) {
+  return path.find(x => {
+    var _x$parentPath;
+
+    return Boolean((_x$parentPath = x.parentPath) === null || _x$parentPath === void 0 ? void 0 : _x$parentPath.isProgram());
+  });
+}
+
+function getPropertyPath(path, name) {
+  const propertyPath = path.get('properties').find(propPath => propPath.isObjectProperty() && t.isIdentifier(propPath.node.key, {
+    name
+  }));
+  return propertyPath !== null && propertyPath !== void 0 && propertyPath.isObjectProperty() ? propertyPath : undefined;
+} // TODO Support import and process them
+
+
+function getDeclaratorPath(path) {
+  if (path !== null && path !== void 0 && path.isIdentifier()) {
+    const {
+      path: bindingPath
+    } = path.scope.getBinding(path.node.name) ?? {};
+    if (bindingPath !== null && bindingPath !== void 0 && bindingPath.isVariableDeclarator() || bindingPath !== null && bindingPath !== void 0 && bindingPath.isFunctionDeclaration() || bindingPath !== null && bindingPath !== void 0 && bindingPath.isImportSpecifier()) return bindingPath;
+  }
+}
+
+function getKindObjectNodePath(path) {
+  if (path.isObjectExpression()) {
+    return getPropertyPath(path, 'title') ? path : undefined;
+  }
+}
+
+function getIdentifiers(path) {
+  return path.map(x => x.isFunctionDeclaration() ? x.get('id') : x.get('id')).map(idPath => idPath.isIdentifier() ? idPath : null).filter(isDefined);
+}
+
+function removeAllPropsExcept(path, propNames) {
+  const getPropName = propPath => propNames.find(names => {
+    const keyPath = propPath.isObjectProperty() ? propPath.get('key') : propPath.get('key');
+    if (!keyPath.isIdentifier()) return;
+    const name = Array.isArray(names) ? names[0] : names;
+    return typeof name == 'string' ? keyPath.isIdentifier({
+      name
+    }) : name(keyPath.node.name);
+  });
+
+  path.get('properties').forEach(propPath => {
+    if (propPath.isObjectProperty() || propPath.isObjectMethod()) {
+      const propName = getPropName(propPath);
+      if (!propName) return propPath.remove();
+      const restNames = Array.isArray(propName) ? propName.slice(1) : [];
+      if (propPath.isObjectProperty() && restNames.length != 0) removeAllExpressionPropsExcept(propPath === null || propPath === void 0 ? void 0 : propPath.get('value'), restNames);
+      if (propPath.isObjectMethod() && restNames[0] == 'storyName') replaceStoryFnToNoop(propPath);
+    } else if (propPath.isSpreadElement()) {
+      removeAllExpressionPropsExcept(propPath.get('argument'), propNames);
+    } else propPath.remove();
+  });
+}
+
+function removeAllPropAssignsExcept(propAssigns, propNames) {
+  for (const [assignPath, props] of propAssigns ?? []) {
+    const restNames = props.reduce((subPropNames, prop) => {
+      const propName = subPropNames.find(names => {
+        const name = Array.isArray(names) ? names[0] : names;
+        return typeof name == 'string' ? name == prop : name(prop);
+      });
+      if (Array.isArray(propName)) return propName.slice(1);
+      if (!propName) assignPath.remove();
+      return [];
+    }, propNames);
+    if (restNames.length != 0) removeAllExpressionPropsExcept(assignPath.get('right'), restNames);
+  }
+}
+
+function replaceStoryFnToNoop(path) {
+  if (path !== null && path !== void 0 && path.isArrowFunctionExpression()) path.get('body').replaceWith(t.blockStatement([]));else if (path !== null && path !== void 0 && path.isFunctionDeclaration()) path.get('body').replaceWith(t.blockStatement([]));else if (path !== null && path !== void 0 && path.isFunctionExpression()) path.get('body').replaceWith(t.blockStatement([]));else if (path !== null && path !== void 0 && path.isObjectMethod()) path.get('body').replaceWith(t.blockStatement([]));
+}
+
+function getAssignmentPathWithProps(refPath) {
+  const assignmentPath = refPath.findParent(parentPath => parentPath.isAssignmentExpression());
+  if (!(assignmentPath !== null && assignmentPath !== void 0 && assignmentPath.isAssignmentExpression())) return;
+  const props = [];
+
+  for (let propPath = refPath.parentPath; propPath != assignmentPath; propPath = propPath.parentPath) {
+    var _propPath;
+
+    if (!((_propPath = propPath) !== null && _propPath !== void 0 && _propPath.isMemberExpression())) return;
+    const propNode = propPath.node.property;
+    if (!t.isIdentifier(propNode)) return;
+    props.push(propNode.name);
+  }
+
+  if (props.length != 0) return [assignmentPath, props];
+}
+
+function getPropertyAssignmentPaths(idPaths) {
+  const assignPaths = new Map();
+  idPaths.forEach(idPath => {
+    var _idPath$scope$getBind;
+
+    const referencePaths = ((_idPath$scope$getBind = idPath.scope.getBinding(idPath.node.name)) === null || _idPath$scope$getBind === void 0 ? void 0 : _idPath$scope$getBind.referencePaths) ?? [];
+    referencePaths.forEach(refPath => {
+      const [assignmentPath, props] = getAssignmentPathWithProps(refPath) ?? [];
+      if (assignmentPath && props) assignPaths.set(assignmentPath, props);
+    });
+  });
+  return assignPaths;
+}
+
+function removeAllExpressionPropsExcept(expressionPath, propNames) {
+  const resolvedDeclPath = getDeclaratorPath(expressionPath);
+  if (expressionPath !== null && expressionPath !== void 0 && expressionPath.isObjectExpression()) removeAllPropsExcept(expressionPath, propNames);else if (expressionPath !== null && expressionPath !== void 0 && expressionPath.isCallExpression()) {
+    if (isObjectAssign(expressionPath)) expressionPath.get('arguments').forEach(argumentPath => removeAllExpressionPropsExcept(argumentPath, storyProps));else if (isTemplateBind(expressionPath)) {
+      const calleePath = expressionPath.get('callee');
+      if (calleePath.isMemberExpression()) removeAllExpressionPropsExcept(calleePath.get('object'), propNames);
+    } else if (propNames[0] == 'storyName') {
+      expressionPath === null || expressionPath === void 0 ? void 0 : expressionPath.replaceWith(t.arrowFunctionExpression([], t.blockStatement([])));
+    }
+  } else if ((expressionPath !== null && expressionPath !== void 0 && expressionPath.isFunctionExpression() || expressionPath !== null && expressionPath !== void 0 && expressionPath.isArrowFunctionExpression()) && propNames[0] == 'storyName') replaceStoryFnToNoop(expressionPath);else if ((!resolvedDeclPath || resolvedDeclPath.isImportSpecifier()) && propNames[0] == 'storyName') expressionPath === null || expressionPath === void 0 ? void 0 : expressionPath.replaceWith(t.arrowFunctionExpression([], t.blockStatement([])));
+
+  if (resolvedDeclPath) {
+    if (!resolvedDeclPath.isImportSpecifier()) removeAllPropAssignsExcept(getPropertyAssignmentPaths(getIdentifiers([resolvedDeclPath])).entries(), propNames);
+    if (resolvedDeclPath.isVariableDeclarator()) removeAllExpressionPropsExcept(resolvedDeclPath.get('init'), propNames);
+    if (resolvedDeclPath.isFunctionDeclaration() && propNames[0] == 'storyName') replaceStoryFnToNoop(resolvedDeclPath);
+  }
+}
+
+function cleanUpStoriesOfCallChain(storiesOfPath) {
+  let callPath = storiesOfPath;
+
+  do {
+    const childCallPath = callPath;
+    const {
+      parentPath: memberPath
+    } = childCallPath;
+    if (!memberPath || !memberPath.isMemberExpression()) return;
+    callPath = memberPath.parentPath;
+    const propPath = memberPath.get('property');
+    if (!callPath.isCallExpression()) return;
+
+    if (propPath.isIdentifier({
+      name: 'add'
+    })) {
+      const [, storyPath, parametersPath] = callPath.get('arguments');
+      storyPath.replaceWith(t.arrowFunctionExpression([], t.blockStatement([])));
+      removeAllExpressionPropsExcept(parametersPath, ['creevey']);
+    } else if (propPath.isIdentifier({
+      name: 'addDecorator'
+    })) {
+      callPath.replaceWith(childCallPath);
+    } else if (propPath.isIdentifier({
+      name: 'addParameters'
+    })) {
+      const [parametersPath] = callPath.get('arguments');
+      removeAllExpressionPropsExcept(parametersPath, ['creevey']);
+    }
+  } while (callPath.parentPath != null);
+}
+
+function recursivelyRemoveUnreferencedBindings(path) {
+  const getUnreferencedBindings = () => {
+    path.scope.crawl();
+    return Object.values(path.scope.bindings).filter(binding => !binding.referenced || binding.referencePaths.every(refPath => refPath.find(x => x.node == binding.path.node)));
+  };
+
+  let bindings = getUnreferencedBindings();
+
+  do {
+    bindings.forEach(binding => !binding.path.removed && binding.path.remove());
+  } while ((bindings = getUnreferencedBindings()).length > 0);
+}
+
+function getUnvisitedRefs(paths, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+state) {
+  const rootPaths = [...new Set(paths.map(findRootPath).filter(isDefined))];
+  const bindings = new Set();
+  rootPaths.forEach(rootPath => {
+    state.visitedTopPaths.add(rootPath);
+    rootPath.traverse({
+      Identifier(identifierPath) {
+        const binding = identifierPath.scope.getBinding(identifierPath.node.name);
+
+        if ((binding === null || binding === void 0 ? void 0 : binding.scope) == rootPath.scope && !state.visitedBindings.has(binding)) {
+          bindings.add(binding);
+          state.visitedBindings.add(binding);
+        }
+      }
+
+    });
+  });
+  const refs = [].concat(...[...bindings].map(b => [b.path, ...b.referencePaths]));
+  return [...new Set(refs)];
+}
+
+export let FileType;
+
+(function (FileType) {
+  FileType[FileType["Invalid"] = -1] = "Invalid";
+  FileType[FileType["Entry"] = 0] = "Entry";
+  FileType[FileType["Preview"] = 1] = "Preview";
+  FileType[FileType["Story"] = 2] = "Story";
+})(FileType || (FileType = {}));
+
+export const commonVisitor = {
+  Program: {
+    enter(path) {
+      path.traverse({
+        TSDeclareFunction(path) {
+          path.remove();
+        },
+
+        TSTypeAliasDeclaration(path) {
+          path.remove();
+        },
+
+        TSInterfaceDeclaration(path) {
+          path.remove();
+        },
+
+        TSTypeAnnotation(path) {
+          path.remove();
+        },
+
+        TSAsExpression(path) {
+          path.replaceWith(path.get('expression'));
+        }
+
+      });
+    },
+
+    exit(path) {
+      if (this.fileType != FileType.Story && this.fileType != FileType.Preview) return;
+      recursivelyRemoveUnreferencedBindings(path);
+      path.traverse({
+        ImportDeclaration(path) {
+          if (path.node.specifiers.length == 0) path.remove();
+        }
+
+      });
+      let refs = [...this.visitedTopPaths];
+
+      while (refs.length > 0) {
+        refs = getUnvisitedRefs(refs, this);
+      }
+
+      path.get('body').filter(x => !this.visitedTopPaths.has(x)).forEach(x => x.remove());
+    }
+
+  }
+};
+export const previewVisitor = {
+  ExportNamedDeclaration(namedPath) {
+    this.visitedTopPaths.add(namedPath);
+    const declarationPath = namedPath.get('declaration');
+    if (!declarationPath.isVariableDeclaration()) return;
+    declarationPath.get('declarations').forEach(declPath => {
+      if (!declPath.isVariableDeclarator()) return;
+      if (t.isIdentifier(declPath.node.id, {
+        name: 'decorators'
+      })) return declPath.remove();
+
+      if (t.isIdentifier(declPath.node.id, {
+        name: 'parameters'
+      })) {
+        removeAllExpressionPropsExcept(declPath.get('init'), ['creevey']);
+      }
+    });
+  },
+
+  CallExpression(rootCallPath) {
+    const rootPath = findRootPath(rootCallPath);
+    const calleePath = rootCallPath.get('callee');
+    if (calleePath.isIdentifier({
+      name: 'configure'
+    }) && rootPath) this.visitedTopPaths.add(rootPath);else if (calleePath.isIdentifier({
+      name: 'addDecorator'
+    })) rootCallPath.remove();else if (calleePath.isIdentifier({
+      name: 'addParameters'
+    })) {
+      const [argPath] = rootCallPath.get('arguments');
+      if (!argPath || !argPath.isObjectExpression()) return;
+      if (rootPath) this.visitedTopPaths.add(rootPath);
+      removeAllPropsExcept(argPath, ['creevey']);
+    }
+  }
+
+};
+export const mdxVisitor = {
+  FunctionDeclaration(functionPath) {
+    var _functionPath$get$nod, _rootPath$scope$getBi;
+
+    const functionName = (_functionPath$get$nod = functionPath.get('id').node) === null || _functionPath$get$nod === void 0 ? void 0 : _functionPath$get$nod.name;
+    if (functionName != 'MDXContent') return;
+    const rootPath = findRootPath(functionPath);
+    const refs = (rootPath === null || rootPath === void 0 ? void 0 : (_rootPath$scope$getBi = rootPath.scope.getBinding(functionName)) === null || _rootPath$scope$getBi === void 0 ? void 0 : _rootPath$scope$getBi.referencePaths) ?? [];
+    refs.forEach(refPath => {
+      var _findRootPath;
+
+      return (_findRootPath = findRootPath(refPath)) === null || _findRootPath === void 0 ? void 0 : _findRootPath.remove();
+    });
+    rootPath === null || rootPath === void 0 ? void 0 : rootPath.remove();
+  }
+
+};
+const kindProps = ['title', 'id', ['parameters', 'creevey'], 'includeStories', 'excludeStories'];
+const storyProps = ['storyName', ['story', 'name', ['parameters', 'creevey', 'docsOnly']], ['parameters', 'creevey', 'docsOnly']];
+const exportsProps = [['default', ...kindProps], [name => name != 'default', ...storyProps]];
+export const storyVisitor = {
+  ExportDefaultDeclaration(defaultPath) {
+    const defaultDeclaration = defaultPath.get('declaration');
+    const declaratorPath = getDeclaratorPath(defaultDeclaration);
+    const kindPath = declaratorPath !== null && declaratorPath !== void 0 && declaratorPath.isVariableDeclarator() ? getKindObjectNodePath(declaratorPath.get('init')) : getKindObjectNodePath(defaultDeclaration);
+    if (!kindPath) return;
+    this.visitedTopPaths.add(defaultPath);
+    removeAllPropsExcept(kindPath, kindProps);
+    if (declaratorPath && !declaratorPath.isImportSpecifier()) removeAllPropAssignsExcept(getPropertyAssignmentPaths(getIdentifiers([declaratorPath])).entries(), kindProps);
+  },
+
+  ExportAllDeclaration(allPath) {
+    const request = allPath.get('source').node.value;
+    this.reexportedStories.set(this.resourcePath, (this.reexportedStories.get(this.resourcePath) ?? new Set()).add(request));
+    this.visitedTopPaths.add(allPath);
+  },
+
+  ExportNamedDeclaration(namedPath) {
+    this.visitedTopPaths.add(namedPath);
+    const declarationPath = namedPath.get('declaration');
+    let storyFnPropAssigns = new Map();
+
+    if (declarationPath.isVariableDeclaration()) {
+      const declarations = declarationPath.get('declarations');
+      declarations.map(x => x.get('init')).forEach(initPath => removeAllExpressionPropsExcept(initPath, storyProps));
+      storyFnPropAssigns = getPropertyAssignmentPaths(getIdentifiers(declarations));
+    } else if (declarationPath.isFunctionDeclaration()) {
+      replaceStoryFnToNoop(declarationPath);
+      storyFnPropAssigns = getPropertyAssignmentPaths(getIdentifiers([declarationPath]));
+    }
+
+    removeAllPropAssignsExcept(storyFnPropAssigns.entries(), storyProps);
+  },
+
+  CallExpression(rootCallPath) {
+    const rootPath = findRootPath(rootCallPath);
+    if (!rootCallPath.get('callee').isIdentifier({
+      name: 'storiesOf'
+    })) return;
+    if (rootPath) this.visitedTopPaths.add(rootPath);
+
+    if (rootPath !== null && rootPath !== void 0 && rootPath.isVariableDeclaration()) {
+      var _rootPath$get$find;
+
+      const storiesIdPath = (_rootPath$get$find = rootPath.get('declarations').find(decl => decl.get('init') == rootCallPath)) === null || _rootPath$get$find === void 0 ? void 0 : _rootPath$get$find.get('id');
+
+      if (storiesIdPath !== null && storiesIdPath !== void 0 && storiesIdPath.isIdentifier()) {
+        var _storiesIdPath$scope$;
+
+        (((_storiesIdPath$scope$ = storiesIdPath.scope.getBinding(storiesIdPath.node.name)) === null || _storiesIdPath$scope$ === void 0 ? void 0 : _storiesIdPath$scope$.referencePaths) ?? []).forEach(cleanUpStoriesOfCallChain);
+      }
+    }
+
+    cleanUpStoriesOfCallChain(rootCallPath);
+  },
+
+  Identifier(identifierPath) {
+    if (isExports(identifierPath)) {
+      const rootPath = findRootPath(identifierPath);
+      if (rootPath) this.visitedTopPaths.add(rootPath);
+      const [assignmentPath, props] = getAssignmentPathWithProps(identifierPath) ?? [];
+
+      if (assignmentPath && props) {
+        if (props.length == 1 && props[0] != 'default') {
+          const declaratorPath = getDeclaratorPath(assignmentPath.get('right'));
+
+          if (declaratorPath && !declaratorPath.isImportSpecifier()) {
+            removeAllPropAssignsExcept(getPropertyAssignmentPaths(getIdentifiers([declaratorPath])).entries(), storyProps);
+          } else {
+            const rightPath = assignmentPath.get('right');
+
+            if (isObjectAssign(rightPath)) {
+              rightPath.get('arguments').forEach(argumentPath => removeAllExpressionPropsExcept(argumentPath, storyProps));
+            } else rightPath.replaceWith(t.arrowFunctionExpression([], t.blockStatement([])));
+          }
+        } else removeAllPropAssignsExcept(new Map([[assignmentPath, props]]).entries(), exportsProps);
+      }
+    }
+
+    if (isModuleExports(identifierPath)) {
+      const rootPath = findRootPath(identifierPath);
+      if (rootPath) this.visitedTopPaths.add(rootPath);
+      const [assignmentPath, props] = getAssignmentPathWithProps(identifierPath) ?? [];
+
+      if (assignmentPath && props) {
+        if (props.length == 1 && props[0] == 'exports') {
+          removeAllExpressionPropsExcept(assignmentPath.get('right'), exportsProps);
+        } else if (props.length == 2 && props[0] == 'exports' && props[1] != 'default') {
+          const declaratorPath = getDeclaratorPath(assignmentPath.get('right'));
+
+          if (declaratorPath && !declaratorPath.isImportSpecifier()) {
+            removeAllPropAssignsExcept(getPropertyAssignmentPaths(getIdentifiers([declaratorPath])).entries(), storyProps);
+          } else {
+            const rightPath = assignmentPath.get('right');
+
+            if (isObjectAssign(rightPath)) {
+              rightPath.get('arguments').forEach(argumentPath => removeAllExpressionPropsExcept(argumentPath, storyProps));
+            } else rightPath.replaceWith(t.arrowFunctionExpression([], t.blockStatement([])));
+          }
+        } else removeAllPropAssignsExcept(new Map([[assignmentPath, props]]).entries(), [['exports', ...exportsProps]]);
+      }
+    }
+  }
+
+};

package/lib/esm/server/loaders/babel/register.js

@@ -0,0 +1,103 @@
+import Module from 'module';
+import fs from 'fs';
+import { isAbsolute, join, relative, resolve } from 'path';
+import { addHook } from 'pirates';
+import { isDefined } from '../../../types';
+import { extensions } from '../../utils';
+import plugin from './creevey-plugin';
+import { hasDocsAddon, hasSvelteCSFAddon } from '../../storybook/helpers';
+let parents = null;
+let story = null; //@ts-expect-error private field doesn't have types
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment
+
+const jsLoader = Module._extensions['.js']; //@ts-expect-error private field doesn't have types
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+
+Module._extensions['.js'] = function (mod, filename) {
+  parents = Object.values(require.cache).filter(m => m === null || m === void 0 ? void 0 : m.children.includes(mod)).filter(isDefined).map(m => m.filename); // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+
+  jsLoader(mod, filename);
+  parents = null;
+};
+
+addHook(() => '', {
+  exts: ['.jpg', '.jpeg', '.png', '.gif', '.eot', '.otf', '.svg', '.ttf', '.woff', '.woff2', '.css', '.less', '.scss', '.styl'],
+  ignoreNodeModules: false
+});
+
+function getRequireContext(rootDir) {
+  return function requireContext(rootPath, deep, filter) {
+    const ids = [];
+    let contextPath; // Relative path
+
+    if (rootPath.startsWith('.')) contextPath = resolve(rootDir, rootPath); // Module path
+    else if (!isAbsolute(rootPath)) contextPath = require.resolve(rootPath); // Absolute path
+    else contextPath = rootPath;
+
+    const traverse = dirPath => {
+      fs.readdirSync(dirPath, {
+        withFileTypes: true
+      }).forEach(dirent => {
+        const filename = dirent.name;
+        const filePath = join(dirPath, filename);
+        if (dirent.isDirectory() && deep) return traverse(filePath);
+        if (dirent.isFile() && ((filter === null || filter === void 0 ? void 0 : filter.test(`./${relative(contextPath, filePath)}`)) ?? true)) return ids.push(filePath);
+      });
+    };
+
+    traverse(contextPath);
+
+    const context = id => {
+      story = id; // eslint-disable-next-line @typescript-eslint/no-var-requires
+
+      const storyModule = require(id);
+
+      story = null;
+      return storyModule;
+    };
+
+    context.id = contextPath;
+
+    context.keys = () => ids;
+
+    context.resolve = id => id;
+
+    return context;
+  };
+}
+
+export default async function register(config, debug = false) {
+  const rootDir = process.cwd();
+  const requireContext = getRequireContext(rootDir);
+  const preview = resolve(config.storybookDir, 'preview');
+  if (hasDocsAddon()) await (await import('../hooks/mdx')).addMDXHook(() => story);
+  if (hasSvelteCSFAddon()) await (await import('../hooks/svelte')).addSvelteHook(() => story); // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+
+  (await import('@babel/register')).default(config.babelOptions({
+    babelrc: false,
+    rootMode: 'upward-optional',
+    ignore: [/node_modules/],
+    extensions: [...extensions, ...(hasDocsAddon() ? ['.mdx'] : []), ...(hasSvelteCSFAddon() ? ['.svelte'] : [])],
+    parserOpts: {
+      sourceType: 'module',
+      plugins: ['classProperties', 'decorators-legacy', 'jsx', 'typescript']
+    },
+    plugins: [[plugin, {
+      debug,
+      preview,
+      parents: () => parents,
+      story: () => story
+    }], ['@babel/plugin-transform-runtime', {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      version: require('@babel/helpers/package.json').version,
+      absoluteRuntime: true,
+      corejs: 3
+    }]],
+    presets: [['@babel/preset-env', {
+      targets: {
+        node: '10'
+      }
+    }]]
+  }));
+  return requireContext;
+}