@storybook/codemod 6.4.0-beta.24 → 6.4.0-beta.28

package/dist/modern/transforms/csf-2-to-3.js

@@ -0,0 +1,152 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* eslint-disable no-underscore-dangle */
+import prettier from 'prettier';
+import * as t from '@babel/types';
+import { formatCsf, loadCsf } from '@storybook/csf-tools';
+import { jscodeshiftToPrettierParser } from '../lib/utils';
+var logger = console;
+
+var _rename = function (annotation) {
+  return annotation === 'storyName' ? 'name' : annotation;
+};
+
+var getTemplateBindVariable = function (init) {
+  return t.isCallExpression(init) && t.isMemberExpression(init.callee) && t.isIdentifier(init.callee.object) && t.isIdentifier(init.callee.property) && init.callee.property.name === 'bind' && (init.arguments.length === 0 || init.arguments.length === 1 && t.isObjectExpression(init.arguments[0]) && init.arguments[0].properties.length === 0) ? init.callee.object.name : null;
+}; // export const A = ...
+// A.parameters = { ... }; <===
+
+
+var isStoryAnnotation = function (stmt, objectExports) {
+  return t.isExpressionStatement(stmt) && t.isAssignmentExpression(stmt.expression) && t.isMemberExpression(stmt.expression.left) && t.isIdentifier(stmt.expression.left.object) && objectExports[stmt.expression.left.object.name];
+};
+
+var isTemplateDeclaration = function (stmt, templates) {
+  return t.isVariableDeclaration(stmt) && stmt.declarations.length === 1 && t.isIdentifier(stmt.declarations[0].id) && templates[stmt.declarations[0].id.name];
+};
+
+var getNewExport = function (stmt, objectExports) {
+  if (t.isExportNamedDeclaration(stmt) && t.isVariableDeclaration(stmt.declaration) && stmt.declaration.declarations.length === 1) {
+    var decl = stmt.declaration.declarations[0];
+
+    if (t.isVariableDeclarator(decl) && t.isIdentifier(decl.id)) {
+      return objectExports[decl.id.name];
+    }
+  }
+
+  return null;
+}; // Remove render function when it matches the global render function in react
+// export default { component: Cat };
+// export const A = (args) => <Cat {...args} />;
+
+
+var isReactGlobalRenderFn = function (csf, storyFn) {
+  var _csf$_meta;
+
+  if ((_csf$_meta = csf._meta) !== null && _csf$_meta !== void 0 && _csf$_meta.component && t.isArrowFunctionExpression(storyFn) && storyFn.params.length === 1 && t.isJSXElement(storyFn.body)) {
+    var openingElement = storyFn.body.openingElement;
+
+    if (openingElement.selfClosing && t.isJSXIdentifier(openingElement.name) && openingElement.attributes.length === 1) {
+      var attr = openingElement.attributes[0];
+      var param = storyFn.params[0];
+
+      if (t.isJSXSpreadAttribute(attr) && t.isIdentifier(attr.argument) && t.isIdentifier(param) && param.name === attr.argument.name && csf._meta.component === openingElement.name.name) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}; // A simple CSF story is a no-arg story without any extra annotations (params, args, etc.)
+
+
+var isSimpleCSFStory = function (init, annotations) {
+  return annotations.length === 0 && t.isArrowFunctionExpression(init) && init.params.length === 0;
+};
+
+function transform({
+  source: source
+}, api, options) {
+  var csf = loadCsf(source, {
+    defaultTitle: 'FIXME'
+  });
+
+  try {
+    csf.parse();
+  } catch (err) {
+    logger.log(`Error ${err}, skipping`);
+    return source;
+  }
+
+  var objectExports = {};
+  Object.entries(csf._storyExports).forEach(function ([key, decl]) {
+    var annotations = Object.entries(csf._storyAnnotations[key]).map(function ([annotation, val]) {
+      return t.objectProperty(t.identifier(_rename(annotation)), val);
+    });
+    var init = decl.init,
+        id = decl.id; // only replace arrow function expressions && template
+    // ignore no-arg stories without annotations
+
+    var template = getTemplateBindVariable(init);
+
+    if (!t.isArrowFunctionExpression(init) && !template || isSimpleCSFStory(init, annotations)) {
+      return;
+    } // Remove the render function when we can hoist the template
+    // const Template = (args) => <Cat {...args} />;
+    // export const A = Template.bind({});
+
+
+    var storyFn = template && csf._templates[template];
+    if (!storyFn) storyFn = init;
+    var keyId = t.identifier(key); // @ts-ignore
+
+    var typeAnnotation = id.typeAnnotation;
+
+    if (typeAnnotation) {
+      keyId.typeAnnotation = typeAnnotation;
+    }
+
+    var renderAnnotation = isReactGlobalRenderFn(csf, storyFn) ? [] : [t.objectProperty(t.identifier('render'), storyFn)];
+    objectExports[key] = t.exportNamedDeclaration(t.variableDeclaration('const', [t.variableDeclarator(keyId, t.objectExpression([...renderAnnotation, ...annotations]))]));
+  });
+
+  var updatedBody = csf._ast.program.body.reduce(function (acc, stmt) {
+    // remove story annotations & template declarations
+    if (isStoryAnnotation(stmt, objectExports) || isTemplateDeclaration(stmt, csf._templates)) {
+      return acc;
+    } // replace story exports with new object exports
+
+
+    var newExport = getNewExport(stmt, objectExports);
+
+    if (newExport) {
+      acc.push(newExport);
+      return acc;
+    } // include unknown statements
+
+
+    acc.push(stmt);
+    return acc;
+  }, []);
+
+  csf._ast.program.body = updatedBody;
+  var output = formatCsf(csf);
+  var prettierConfig = prettier.resolveConfig.sync('.', {
+    editorconfig: true
+  }) || {
+    printWidth: 100,
+    tabWidth: 2,
+    bracketSpacing: true,
+    trailingComma: 'es5',
+    singleQuote: true
+  };
+  return prettier.format(output, _objectSpread(_objectSpread({}, prettierConfig), {}, {
+    parser: jscodeshiftToPrettierParser(options === null || options === void 0 ? void 0 : options.parser)
+  }));
+}
+
+export default transform;

package/dist/modern/transforms/csf-hoist-story-annotations.js

@@ -0,0 +1,86 @@
+var getContainingStatement = function (n) {
+  if (n.node.type.endsWith('Statement')) {
+    return n;
+  }
+
+  return getContainingStatement(n.parent);
+};
+/**
+ * Hoist CSF .story annotations
+ *
+ * For example:
+ *
+ * ```
+ * export const Basic = () => <Button />
+ * Basic.story = {
+ *   name: 'foo',
+ *   parameters: { ... },
+ *   decorators = [ ... ],
+ * };
+ * ```
+ *
+ * Becomes:
+ *
+ * ```
+ * export const Basic = () => <Button />
+ * Basic.storyName = 'foo';
+ * Basic.parameters = { ... };
+ * Basic.decorators = [ ... ];
+ * ```
+ */
+
+
+export default function transformer(file, api) {
+  var j = api.jscodeshift;
+  var root = j(file.source);
+
+  var renameKey = function (exp) {
+    return exp.type === 'Identifier' && exp.name === 'name' ? j.identifier('storyName') : exp;
+  }; // 1. If the program does not have `export default { title: '....' }, skip it
+
+
+  var defaultExportWithTitle = root.find(j.ExportDefaultDeclaration).filter(function (def) {
+    return def.node.declaration.type === 'ObjectExpression' && def.node.declaration.properties.map(function (p) {
+      return p.key.name;
+    }).includes('title');
+  });
+
+  if (defaultExportWithTitle.size() === 0) {
+    return root.toSource();
+  } // 2. Replace each Foo.story = { x: xVal } with Foo.x = xVal;
+
+
+  var storyAssignments = root.find(j.AssignmentExpression).filter(function (exp) {
+    var _exp$node = exp.node,
+        left = _exp$node.left,
+        right = _exp$node.right;
+    return left.type === 'MemberExpression' && left.object.type === 'Identifier' && left.property.type === 'Identifier' && left.property.name === 'story' && right.type === 'ObjectExpression';
+  });
+  storyAssignments.forEach(function (exp) {
+    var _exp$node2 = exp.node,
+        left = _exp$node2.left,
+        right = _exp$node2.right;
+    right.properties.forEach(function (prop) {
+      var stmt = getContainingStatement(exp);
+      stmt.insertBefore(j.assignmentStatement('=', j.memberExpression(left.object, renameKey(prop.key)), prop.value));
+    });
+  }); // 3. Remove the .story annotations
+
+  storyAssignments.remove(); // 4. Replace each Foo.story.x with Foo.x;
+
+  var storyOverrides = root.find(j.AssignmentExpression).filter(function (exp) {
+    var left = exp.node.left;
+    return left.type === 'MemberExpression' && left.object.type === 'MemberExpression' && left.object.property.type === 'Identifier' && left.object.property.name === 'story' && left.property.type === 'Identifier' // ?? ANNOTATION_FIELDS.includes(right.property.name)
+    ;
+  });
+  storyOverrides.replaceWith(function (exp) {
+    var _exp$node3 = exp.node,
+        left = _exp$node3.left,
+        right = _exp$node3.right;
+    return j.assignmentExpression('=', j.memberExpression(left.object.object, renameKey(left.property)), right);
+  }); // 4. Render the updated tree
+
+  return root.toSource({
+    quote: 'single'
+  });
+}

package/dist/modern/transforms/csf-to-mdx.js

@@ -0,0 +1,188 @@
+import { prettyPrint } from 'recast';
+import { isExportStory } from '@storybook/csf';
+
+function exportMdx(root, options) {
+  // eslint-disable-next-line no-underscore-dangle
+  var path = root.__paths[0]; // FIXME: insert the title as markdown after all of the imports
+
+  return path.node.program.body.map(function (n) {
+    var _prettyPrint = prettyPrint(n, options),
+        code = _prettyPrint.code;
+
+    if (n.type === 'JSXElement') {
+      return `${code}\n`;
+    }
+
+    return code;
+  }).join('\n');
+}
+
+function parseIncludeExclude(prop) {
+  var _prettyPrint2 = prettyPrint(prop, {}),
+      code = _prettyPrint2.code; // eslint-disable-next-line no-eval
+
+
+  return eval(code);
+}
+/**
+ * Convert a component's module story file into an MDX file
+ *
+ * For example:
+ *
+ * ```
+ * input { Button } from './Button';
+ * export default {
+ *   title: 'Button'
+ * }
+ * export const story = () => <Button label="The Button" />;
+ * ```
+ *
+ * Becomes:
+ *
+ * ```
+ * import { Meta, Story } from '@storybook/addon-docs';
+ * input { Button } from './Button';
+ *
+ * <Meta title='Button' />
+ *
+ * <Story name='story'>
+ *   <Button label="The Button" />
+ * </Story>
+ * ```
+ */
+
+
+export default function transformer(file, api) {
+  var j = api.jscodeshift;
+  var root = j(file.source); // FIXME: save out all the storyFn.story = { ... }
+
+  var storyKeyToStory = {}; // save out includeStories / excludeStories
+
+  var meta = {};
+
+  function makeAttr(key, val) {
+    return j.jsxAttribute(j.jsxIdentifier(key), val.type === 'Literal' ? val : j.jsxExpressionContainer(val));
+  }
+
+  function getStoryContents(node) {
+    return node.type === 'ArrowFunctionExpression' && node.body.type === 'JSXElement' ? node.body : j.jsxExpressionContainer(node);
+  }
+
+  function getName(storyKey) {
+    var story = storyKeyToStory[storyKey];
+
+    if (story) {
+      var name = story.properties.find(function (prop) {
+        return prop.key.name === 'name';
+      });
+
+      if (name && name.value.type === 'Literal') {
+        return name.value.value;
+      }
+    }
+
+    return storyKey;
+  }
+
+  function getStoryAttrs(storyKey) {
+    var attrs = [];
+    var story = storyKeyToStory[storyKey];
+
+    if (story) {
+      story.properties.forEach(function (prop) {
+        var key = prop.key,
+            value = prop.value;
+
+        if (key.name !== 'name') {
+          attrs.push(makeAttr(key.name, value));
+        }
+      });
+    }
+
+    return attrs;
+  } // 1. If the program does not have `export default { title: '....' }, skip it
+
+
+  var defaultExportWithTitle = root.find(j.ExportDefaultDeclaration).filter(function (def) {
+    return def.node.declaration.properties.map(function (p) {
+      return p.key.name;
+    }).includes('title');
+  });
+
+  if (defaultExportWithTitle.size() === 0) {
+    return root.toSource();
+  } // 2a. Add imports from '@storybook/addon-docs'
+
+
+  root.find(j.ImportDeclaration).at(-1).insertAfter(j.emptyStatement()).insertAfter(j.importDeclaration([j.importSpecifier(j.identifier('Meta')), j.importSpecifier(j.identifier('Story'))], j.literal('@storybook/addon-docs'))); // 2b. Remove react import which is implicit
+
+  root.find(j.ImportDeclaration).filter(function (decl) {
+    return decl.node.source.value === 'react';
+  }).remove(); // 3. Save out all the excluded stories
+
+  defaultExportWithTitle.forEach(function (exp) {
+    exp.node.declaration.properties.forEach(function (p) {
+      if (['includeStories', 'excludeStories'].includes(p.key.name)) {
+        meta[p.key.name] = parseIncludeExclude(p.value);
+      }
+    });
+  }); // 4. Collect all the story exports in storyKeyToStory[key] = null;
+
+  var namedExports = root.find(j.ExportNamedDeclaration);
+  namedExports.forEach(function (exp) {
+    var storyKey = exp.node.declaration.declarations[0].id.name;
+
+    if (isExportStory(storyKey, meta)) {
+      storyKeyToStory[storyKey] = null;
+    }
+  }); // 5. Collect all the storyKey.story in storyKeyToStory and also remove them
+
+  var storyAssignments = root.find(j.AssignmentExpression).filter(function (exp) {
+    var left = exp.node.left;
+    return left.type === 'MemberExpression' && left.object.type === 'Identifier' && left.object.name in storyKeyToStory && left.property.type === 'Identifier' && left.property.name === 'story';
+  });
+  storyAssignments.forEach(function (exp) {
+    var _exp$node = exp.node,
+        left = _exp$node.left,
+        right = _exp$node.right;
+    storyKeyToStory[left.object.name] = right;
+  });
+  storyAssignments.remove(); // 6. Convert the default export to <Meta />
+
+  defaultExportWithTitle.replaceWith(function (exp) {
+    var jsxId = j.jsxIdentifier('Meta');
+    var attrs = [];
+    exp.node.declaration.properties.forEach(function (prop) {
+      var key = prop.key,
+          value = prop.value;
+
+      if (!['includeStories', 'excludeStories'].includes(key.name)) {
+        attrs.push(makeAttr(key.name, value));
+      }
+    });
+    var opening = j.jsxOpeningElement(jsxId, attrs);
+    opening.selfClosing = true;
+    return j.jsxElement(opening);
+  }); // 7. Convert all the named exports to <Story>...</Story>
+
+  namedExports.replaceWith(function (exp) {
+    var storyKey = exp.node.declaration.declarations[0].id.name;
+
+    if (!isExportStory(storyKey, meta)) {
+      return exp.node;
+    }
+
+    var jsxId = j.jsxIdentifier('Story');
+    var name = getName(storyKey);
+    var attributes = [makeAttr('name', j.literal(name)), ...getStoryAttrs(storyKey)];
+    var opening = j.jsxOpeningElement(jsxId, attributes);
+    var closing = j.jsxClosingElement(jsxId);
+    var children = [getStoryContents(exp.node.declaration.declarations[0].init)];
+    return j.jsxElement(opening, closing, children);
+  });
+  return exportMdx(root, {
+    quote: 'single',
+    trailingComma: 'true',
+    tabWidth: 2
+  });
+}

package/dist/modern/transforms/mdx-to-csf.js

@@ -0,0 +1,139 @@
+// import recast from 'recast';
+import mdx from '@mdx-js/mdx';
+import prettier from 'prettier';
+import { sanitizeName } from '../lib/utils';
+/**
+ * Convert a component's MDX file into module story format
+ */
+
+export default function transformer(file, api) {
+  var j = api.jscodeshift;
+  var code = mdx.sync(file.source, {});
+  var root = j(code);
+
+  function parseJsxAttributes(attributes) {
+    var result = {};
+    attributes.forEach(function (attr) {
+      var key = attr.name.name;
+      var val = attr.value.type === 'JSXExpressionContainer' ? attr.value.expression : attr.value;
+      result[key] = val;
+    });
+    return result;
+  }
+
+  function genObjectExpression(attrs) {
+    return j.objectExpression(Object.entries(attrs).map(function ([key, val]) {
+      return j.property('init', j.identifier(key), val);
+    }));
+  }
+
+  function convertToStories(path) {
+    var base = j(path);
+    var meta = {};
+    var includeStories = [];
+    var storyStatements = []; // get rid of all mdxType junk
+
+    base.find(j.JSXAttribute).filter(function (attr) {
+      return attr.node.name.name === 'mdxType';
+    }).remove(); // parse <Meta title="..." />
+
+    base.find(j.JSXElement).filter(function (elt) {
+      return elt.node.openingElement.name.name === 'Meta';
+    }).forEach(function (elt) {
+      var attrs = parseJsxAttributes(elt.node.openingElement.attributes);
+      Object.assign(meta, attrs);
+    }); // parse <Story name="..." />
+
+    base.find(j.JSXElement).filter(function (elt) {
+      return elt.node.openingElement.name.name === 'Story';
+    }).forEach(function (elt) {
+      var attrs = parseJsxAttributes(elt.node.openingElement.attributes);
+
+      if (attrs.name) {
+        var storyKey = sanitizeName(attrs.name.value);
+        includeStories.push(storyKey);
+
+        if (storyKey === attrs.name.value) {
+          delete attrs.name;
+        }
+
+        var body = elt.node.children.find(function (n) {
+          return n.type !== 'JSXText';
+        }) || j.literal(elt.node.children[0].value);
+
+        if (body.type === 'JSXExpressionContainer') {
+          body = body.expression;
+        }
+
+        storyStatements.push(j.exportDeclaration(false, j.variableDeclaration('const', [j.variableDeclarator(j.identifier(storyKey), body.type === 'ArrowFunctionExpression' ? body : j.arrowFunctionExpression([], body))])));
+
+        if (Object.keys(attrs).length > 0) {
+          storyStatements.push(j.assignmentStatement('=', j.memberExpression(j.identifier(storyKey), j.identifier('story')), genObjectExpression(attrs)));
+        }
+
+        storyStatements.push(j.emptyStatement());
+      }
+    });
+
+    if (root.find(j.ExportNamedDeclaration).size() > 0) {
+      meta.includeStories = j.arrayExpression(includeStories.map(function (key) {
+        return j.literal(key);
+      }));
+    }
+
+    var statements = [j.exportDefaultDeclaration(genObjectExpression(meta)), j.emptyStatement(), ...storyStatements];
+    var lastStatement = root.find(j.Statement).at(-1);
+    statements.reverse().forEach(function (stmt) {
+      lastStatement.insertAfter(stmt);
+    });
+    base.remove();
+  }
+
+  root.find(j.ExportDefaultDeclaration).forEach(convertToStories); // strip out Story/Meta import and MDX junk
+  //   /* @jsx mdx */
+
+  root.find(j.ImportDeclaration).at(0).replaceWith(function (exp) {
+    return j.importDeclaration(exp.node.specifiers, exp.node.source);
+  }); //  import { Story, Meta } from '@storybook/addon-docs';
+
+  root.find(j.ImportDeclaration).filter(function (exp) {
+    return exp.node.source.value === '@storybook/addon-docs';
+  }).remove(); //   const makeShortcode = ...
+  //   const layoutProps = {};
+  //   const MDXLayout = 'wrapper';
+
+  var MDX_DECLS = ['makeShortcode', 'layoutProps', 'MDXLayout'];
+  root.find(j.VariableDeclaration).filter(function (decl) {
+    return decl.node.declarations.length === 1 && MDX_DECLS.includes(decl.node.declarations[0].id.name);
+  }).remove(); //   const Source = makeShortcode('Source');
+
+  root.find(j.VariableDeclarator).filter(function (expr) {
+    return expr.node.init.type === 'CallExpression' && expr.node.init.callee.type === 'Identifier' && expr.node.init.callee.name === 'makeShortcode';
+  }).remove(); //   MDXContent.isMDXComponent = true;
+
+  root.find(j.AssignmentExpression).filter(function (expr) {
+    return expr.node.left.type === 'MemberExpression' && expr.node.left.object.type === 'Identifier' && expr.node.left.object.name === 'MDXContent';
+  }).remove(); // Add back `import React from 'react';` which is implicit in MDX
+
+  var react = root.find(j.ImportDeclaration).filter(function (decl) {
+    return decl.node.source.value === 'react';
+  });
+
+  if (react.size() === 0) {
+    root.find(j.Statement).at(0).insertBefore(j.importDeclaration([j.importDefaultSpecifier(j.identifier('React'))], j.literal('react')));
+  }
+
+  var source = root.toSource({
+    trailingComma: true,
+    quote: 'single',
+    tabWidth: 2
+  });
+  return prettier.format(source, {
+    parser: 'babel',
+    printWidth: 100,
+    tabWidth: 2,
+    bracketSpacing: true,
+    trailingComma: 'es5',
+    singleQuote: true
+  });
+}

package/dist/modern/transforms/move-builtin-addons.js

@@ -0,0 +1,50 @@
+import "core-js/modules/es.symbol.description.js";
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+export default function transformer(file, api) {
+  var j = api.jscodeshift;
+
+  var createImportDeclaration = function (specifiers, source) {
+    return j.importDeclaration(specifiers.map(function (s) {
+      return j.importSpecifier(j.identifier(s));
+    }), j.literal(source));
+  };
+
+  var deprecates = {
+    action: [['action'], '@storybook/addon-actions'],
+    linkTo: [['linkTo'], '@storybook/addon-links']
+  };
+  var transform = j(file.source).find(j.ImportDeclaration).filter(function (i) {
+    return i.value.source.value === '@storybook/react';
+  }).forEach(function (i) {
+    var importStatement = i.value;
+    importStatement.specifiers = importStatement.specifiers.filter(function (specifier) {
+      var item = deprecates[specifier.local.name];
+
+      if (item) {
+        var _item = _slicedToArray(item, 2),
+            specifiers = _item[0],
+            moduleName = _item[1];
+
+        i.insertAfter(createImportDeclaration(specifiers, moduleName));
+        return false;
+      }
+
+      return specifier;
+    });
+  });
+  return transform.toSource({
+    quote: 'single'
+  });
+}