revise the variable name back to "t" for consistency

Author: quantizor

src/index.js

@@ -5,22 +5,22 @@ import templateLiterals from './visitors/templateLiterals'
 import assignStyledRequired from './visitors/assignStyledRequired'
 import rewriteStyledImport from './visitors/rewriteStyledImport'
 
-export default function({ types }) {
+export default function({ types: t }) {
   return {
     visitor: {
       ImportDeclaration(path, state) {
-        rewriteStyledImport(types)(path, state)
+        rewriteStyledImport(t)(path, state)
       },
       MemberExpression(path, state) {
-        desugarStyled(types)(path, state)
+        desugarStyled(t)(path, state)
       },
       TaggedTemplateExpression(path, state) {
-        minify(types)(path, state)
-        displayNameAndId(types)(path, state)
-        templateLiterals(types)(path, state)
+        minify(t)(path, state)
+        displayNameAndId(t)(path, state)
+        templateLiterals(t)(path, state)
       },
       VariableDeclarator(path, state) {
-        assignStyledRequired(types)(path, state)
+        assignStyledRequired(t)(path, state)
       },
     },
   }

src/utils/detectors.js

@@ -41,19 +41,19 @@ const importLocalName = (name, state) => {
   return localName
 }
 
-export const isStyled = types => (tag, state) => {
+export const isStyled = t => (tag, state) => {
   if (
-    types.isCallExpression(tag) &&
-    types.isMemberExpression(tag.callee) &&
+    t.isCallExpression(tag) &&
+    t.isMemberExpression(tag.callee) &&
     tag.callee.property.name !== 'default' /** ignore default for #93 below */
   ) {
     // styled.something()
-    return isStyled(types)(tag.callee.object, state)
+    return isStyled(t)(tag.callee.object, state)
   } else {
     return (
-      (types.isMemberExpression(tag) &&
+      (t.isMemberExpression(tag) &&
         tag.object.name === importLocalName('default', state)) ||
-      (types.isCallExpression(tag) &&
+      (t.isCallExpression(tag) &&
         tag.callee.name === importLocalName('default', state)) ||
       /**
        * #93 Support require()
@@ -63,31 +63,31 @@ export const isStyled = types => (tag, state) => {
        * - styled.default.something()
        */
       (state.styledRequired &&
-        types.isMemberExpression(tag) &&
-        types.isMemberExpression(tag.object) &&
+        t.isMemberExpression(tag) &&
+        t.isMemberExpression(tag.object) &&
         tag.object.property.name === 'default' &&
         tag.object.object.name === state.styledRequired) ||
       (state.styledRequired &&
-        types.isCallExpression(tag) &&
-        types.isMemberExpression(tag.callee) &&
+        t.isCallExpression(tag) &&
+        t.isMemberExpression(tag.callee) &&
         tag.callee.property.name === 'default' &&
         tag.callee.object.name === state.styledRequired)
     )
   }
 }
 
-export const isCSSHelper = types => (tag, state) =>
-  types.isIdentifier(tag) && tag.name === importLocalName('css', state)
+export const isCSSHelper = t => (tag, state) =>
+  t.isIdentifier(tag) && tag.name === importLocalName('css', state)
 
-export const isCreateGlobalStyleHelper = types => (tag, state) =>
-  types.isIdentifier(tag) &&
+export const isCreateGlobalStyleHelper = t => (tag, state) =>
+  t.isIdentifier(tag) &&
   tag.name === importLocalName('createGlobalStyle', state)
 
-export const isInjectGlobalHelper = types => (tag, state) =>
-  types.isIdentifier(tag) && tag.name === importLocalName('injectGlobal', state)
+export const isInjectGlobalHelper = t => (tag, state) =>
+  t.isIdentifier(tag) && tag.name === importLocalName('injectGlobal', state)
 
-export const isKeyframesHelper = types => (tag, state) =>
-  types.isIdentifier(tag) && tag.name === importLocalName('keyframes', state)
+export const isKeyframesHelper = t => (tag, state) =>
+  t.isIdentifier(tag) && tag.name === importLocalName('keyframes', state)
 
-export const isHelper = types => (tag, state) =>
-  isCSSHelper(types)(tag, state) || isKeyframesHelper(types)(tag, state)
+export const isHelper = t => (tag, state) =>
+  isCSSHelper(t)(tag, state) || isKeyframesHelper(t)(tag, state)

src/utils/getName.js

@@ -6,7 +6,7 @@
  * @return {String}   The target
  */
 
-export default types => path => {
+export default t => path => {
   let namedNode
 
   path.find(path => {
@@ -32,10 +32,10 @@ export default types => path => {
   })
 
   // foo.bar -> bar
-  if (types.isMemberExpression(namedNode)) {
+  if (t.isMemberExpression(namedNode)) {
     namedNode = namedNode.property
   }
 
   // identifiers are the only thing we can reliably get a name from
-  return types.isIdentifier(namedNode) ? namedNode.name : undefined
+  return t.isIdentifier(namedNode) ? namedNode.name : undefined
 }

src/visitors/assignStyledRequired.js

@@ -1,13 +1,13 @@
 import { isValidTopLevelImport } from '../utils/detectors'
 
-export default types => (path, state) => {
+export default t => (path, state) => {
   if (
-    types.isCallExpression(path.node.init) &&
-    types.isIdentifier(path.node.init.callee) &&
+    t.isCallExpression(path.node.init) &&
+    t.isIdentifier(path.node.init.callee) &&
     path.node.init.callee.name === 'require' &&
     path.node.init.arguments &&
     path.node.init.arguments[0] &&
-    types.isLiteral(path.node.init.arguments[0]) &&
+    t.isLiteral(path.node.init.arguments[0]) &&
     isValidTopLevelImport(path.node.init.arguments[0].value)
   ) {
     state.styledRequired = path.node.id.name

src/visitors/desugarStyled.js

@@ -1,11 +1,11 @@
 import get from 'lodash/get'
 import { isStyled } from '../utils/detectors'
 
-export default types => (path, state) => {
+export default t => (path, state) => {
   /**
    * Handles both "styled.div" and "styled_default.default.div" (transpiled output)
    */
-  if (isStyled(types)(path.node, state)) {
+  if (isStyled(t)(path.node, state)) {
     /**
      * e.g. "div"
      */
@@ -16,17 +16,15 @@ export default types => (path, state) => {
      * "styled_default.default.div", we want to preserve the "styled_default.default"
      * part and just reuse that AST object.
      */
-    const leftSide = types.isMemberExpression(path.node.object)
+    const leftSide = t.isMemberExpression(path.node.object)
       ? path.node.object
-      : types.identifier(path.node.object.name)
+      : t.identifier(path.node.object.name)
 
     if (sugar) {
       /**
        * "styled.div" -> "styled('div')"
        */
-      path.replaceWith(
-        types.callExpression(leftSide, [types.stringLiteral(sugar)])
-      )
+      path.replaceWith(t.callExpression(leftSide, [t.stringLiteral(sugar)]))
     }
   }
 }

src/visitors/displayNameAndId.js

@@ -6,33 +6,33 @@ import prefixLeadingDigit from '../utils/prefixDigit'
 import hash from '../utils/hash'
 import { isStyled } from '../utils/detectors'
 
-const addConfig = types => (path, displayName, componentId) => {
+const addConfig = t => (path, displayName, componentId) => {
   if (!displayName && !componentId) {
     return
   }
 
   const withConfigProps = []
   if (displayName) {
     withConfigProps.push(
-      types.objectProperty(
-        types.identifier('displayName'),
-        types.stringLiteral(displayName)
+      t.objectProperty(
+        t.identifier('displayName'),
+        t.stringLiteral(displayName)
       )
     )
   }
   if (componentId) {
     withConfigProps.push(
-      types.objectProperty(
-        types.identifier('componentId'),
-        types.stringLiteral(componentId)
+      t.objectProperty(
+        t.identifier('componentId'),
+        t.stringLiteral(componentId)
       )
     )
   }
 
   // Replace x`...` with x.withConfig({ })`...`
-  path.node.tag = types.callExpression(
-    types.memberExpression(path.node.tag, types.identifier('withConfig')),
-    [types.objectExpression(withConfigProps)]
+  path.node.tag = t.callExpression(
+    t.memberExpression(path.node.tag, t.identifier('withConfig')),
+    [t.objectExpression(withConfigProps)]
   )
 }
 
@@ -46,9 +46,9 @@ const getBlockName = file => {
     : path.basename(path.dirname(file.opts.filename))
 }
 
-const getDisplayName = types => (path, state) => {
+const getDisplayName = t => (path, state) => {
   const { file } = state
-  const componentName = getName(types)(path)
+  const componentName = getName(t)(path)
   if (file) {
     const blockName = getBlockName(file)
     if (blockName === componentName) {
@@ -121,13 +121,13 @@ const getComponentId = state => {
   return `${prefixLeadingDigit(getFileHash(state))}-${getNextId(state)}`
 }
 
-export default types => (path, state) => {
-  if (isStyled(types)(path.node.tag, state)) {
+export default t => (path, state) => {
+  if (isStyled(t)(path.node.tag, state)) {
     const displayName =
       useDisplayName(state) &&
-      getDisplayName(types)(path, useFileName(state) && state)
+      getDisplayName(t)(path, useFileName(state) && state)
 
-    addConfig(types)(
+    addConfig(t)(
       path,
       displayName && displayName.replace(/[^_a-zA-Z0-9-]/g, ''),
       useSSR(state) && getComponentId(state)

src/visitors/minify.js

@@ -2,11 +2,10 @@ import { useMinify } from '../utils/options'
 import { isStyled, isHelper } from '../utils/detectors'
 import { minifyRawValues, minifyCookedValues } from '../minify'
 
-export default types => (path, state) => {
+export default t => (path, state) => {
   if (
     useMinify(state) &&
-    (isStyled(types)(path.node.tag, state) ||
-      isHelper(types)(path.node.tag, state))
+    (isStyled(t)(path.node.tag, state) || isHelper(t)(path.node.tag, state))
   ) {
     const templateLiteral = path.node.quasi
     const quasisLength = templateLiteral.quasis.length

src/visitors/rewriteStyledImport.js

@@ -3,8 +3,8 @@
  * then use a lighter-weight version of s-c since those element names don't need to be kept around
  * ahead of time.
  */
-export default types => path => {
+export default t => path => {
   if (path.node.source.value === 'styled-components') {
-    path.node.source = types.stringLiteral('styled-components/no-tags')
+    path.node.source = t.stringLiteral('styled-components/no-tags')
   }
 }

src/visitors/templateLiterals/index.js

@@ -1,8 +1,8 @@
 import { useTranspileTemplateLiterals } from '../../utils/options'
 import transpile from './transpile'
 
-export default types => (path, state) => {
+export default t => (path, state) => {
   if (useTranspileTemplateLiterals(state)) {
-    transpile(types)(path, state)
+    transpile(t)(path, state)
   }
 }

src/visitors/templateLiterals/transpile.js

@@ -1,19 +1,16 @@
 import { isStyled, isHelper } from '../../utils/detectors'
 
-export default types => (path, state) => {
-  if (
-    isStyled(types)(path.node.tag, state) ||
-    isHelper(types)(path.node.tag, state)
-  ) {
+export default t => (path, state) => {
+  if (isStyled(t)(path.node.tag, state) || isHelper(t)(path.node.tag, state)) {
     const {
       tag: callee,
       quasi: { quasis, expressions },
     } = path.node
 
-    const values = types.arrayExpression(
-      quasis.map(quasi => types.stringLiteral(quasi.value.cooked))
+    const values = t.arrayExpression(
+      quasis.map(quasi => t.stringLiteral(quasi.value.cooked))
     )
 
-    path.replaceWith(types.callExpression(callee, [values, ...expressions]))
+    path.replaceWith(t.callExpression(callee, [values, ...expressions]))
   }
 }