creevey 0.9.0-beta.1 → 0.9.0-non-webpack.0

package/lib/esm/server/extract.js

@@ -0,0 +1,34 @@
+import { denormalizeStoryParameters } from '../shared';
+import { subscribeOn } from './messages';
+import { loadTestsFromStories, saveStoriesJson, saveTestsJson } from './stories';
+import { isStorybookVersionGreaterThan, isStorybookVersionLessThan } from './storybook/helpers';
+import { extractStoriesData } from './storybook/providers/nodejs';
+export default async function extract(config, options) {
+  if (config.useWebpackToExtractTests && process.env.__CREEVEY_ENV__ != 'test') {
+    await new Promise((resolve, reject) => {
+      subscribeOn('webpack', message => {
+        switch (message.type) {
+          case 'success':
+            return resolve();
+
+          case 'fail':
+            return reject();
+        }
+      });
+      void (async () => (await import('./loaders/webpack/compile')).default(config, options))();
+    });
+  }
+
+  const tests = await loadTestsFromStories(Object.keys(config.browsers), async () => {
+    const data = await extractStoriesData(config, {
+      watch: false,
+      debug: options.debug
+    });
+    const stories = isStorybookVersionLessThan(6) || isStorybookVersionGreaterThan(6, 3) ? data.stories : denormalizeStoryParameters(data);
+    if (options.extract) saveStoriesJson(data, options.extract);
+    return stories;
+  });
+  if (options.tests) saveTestsJson(tests); // eslint-disable-next-line no-process-exit
+
+  process.exit(0);
+}

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]]);
+      }
+    }
+  }
+
+};