revert: remove jsdoc types

Author: brunos3d

packages/babel-plugin/src/index.js

@@ -1,4 +1,4 @@
-import { declare } from '@babel/helper-plugin-utils'
+import { declare } from "@babel/helper-plugin-utils";
 import syntaxDynamicImport from '@babel/plugin-syntax-dynamic-import'
 import chunkNameProperty from './properties/chunkName'
 import isReadyProperty from './properties/isReady'
@@ -20,194 +20,164 @@ const properties = [
 
 const LOADABLE_COMMENT = '#__LOADABLE__'
 
-/**
- * The options for the plugin
- * @typedef {Object} LoadabelBabelPluginOptions
- * @property {string} [defaultImportSpecifier] - The default import specifier, defaults to `loadable`
- * @property {boolean} [moduleFederation] - Whether to use module federation
- */
-
-/**
- * The options for the plugin
- * @typedef {Object} PropertyFactoryOptions
- * @property {import('@babel/core').NodePath<import('@babel/types').CallExpression>} callPath
- * @property {import('@babel/core').NodePath<import('@babel/types').FunctionExpression | import('@babel/types').ArrowFunctionExpression | import('@babel/types').ObjectMethod>} funcPath
- * @property {import('@babel/core').NodePath<import('@babel/types').ObjectExpression>} path
- */
-
-/**
- * The factory for a property
- * @typedef {Function} PropertyFactory
- * @param {PropertyFactoryOptions} options
- * @returns {import('@babel/types').ObjectMethod}
- */
-
-const loadablePlugin = declare(
-  /**
-   *
-   * @param {import('@babel/helper-plugin-utils').BabelAPI} api
-   * @param {LoadabelBabelPluginOptions} babelOptions
-   * @returns {import('@babel/core').PluginObj}
-   */
-  (api, babelOptions) => {
-    const { defaultImportSpecifier = 'loadable' } = babelOptions
-
-    const { types: t } = api
-
-    function collectImportCallPaths(startPath) {
-      const imports = []
-      startPath.traverse({
-        Import(importPath) {
-          imports.push(importPath.parentPath)
-        },
-      })
-      return imports
-    }
+const loadablePlugin = declare((api, babelOptions) => {
+  const { defaultImportSpecifier = 'loadable' } = babelOptions
 
-    const propertyFactories = properties.map(init => init(api, babelOptions))
+  const { types: t } = api
 
-    function isValidIdentifier(
-      path,
-      loadableImportSpecifier,
-      lazyImportSpecifier,
+  function collectImportCallPaths(startPath) {
+    const imports = []
+    startPath.traverse({
+      Import(importPath) {
+        imports.push(importPath.parentPath)
+      },
+    })
+    return imports
+  }
+
+  const propertyFactories = properties.map(init => init(api, babelOptions))
+
+  function isValidIdentifier(
+    path,
+    loadableImportSpecifier,
+    lazyImportSpecifier,
+  ) {
+    // `loadable()`
+    if (
+      loadableImportSpecifier &&
+      path.get('callee').isIdentifier({ name: loadableImportSpecifier })
     ) {
-      // `loadable()`
-      if (
-        loadableImportSpecifier &&
-        path.get('callee').isIdentifier({ name: loadableImportSpecifier })
-      ) {
-        return true
-      }
-
-      // `lazy()`
-      if (
-        lazyImportSpecifier &&
-        path.get('callee').isIdentifier({ name: lazyImportSpecifier })
-      ) {
-        return true
-      }
-
-      // `loadable.lib()`
-      return (
-        loadableImportSpecifier &&
-        path.get('callee').isMemberExpression() &&
-        path
-          .get('callee.object')
-          .isIdentifier({ name: loadableImportSpecifier }) &&
-        path.get('callee.property').isIdentifier({ name: 'lib' })
-      )
+      return true
     }
 
-    function hasLoadableComment(path) {
-      const comments = path.get('leadingComments')
-      const comment = comments.find(
-        ({ node }) =>
-          node && node.value && String(node.value).includes(LOADABLE_COMMENT),
-      )
-      if (!comment) return false
-      comment.remove()
+    // `lazy()`
+    if (
+      lazyImportSpecifier &&
+      path.get('callee').isIdentifier({ name: lazyImportSpecifier })
+    ) {
       return true
     }
 
-    function getFuncPath(path) {
-      const funcPath = path.isCallExpression() ? path.get('arguments.0') : path
-      if (
-        !funcPath.isFunctionExpression() &&
-        !funcPath.isArrowFunctionExpression() &&
-        !funcPath.isObjectMethod()
-      ) {
-        return null
-      }
-      return funcPath
+    // `loadable.lib()`
+    return (
+      loadableImportSpecifier &&
+      path.get('callee').isMemberExpression() &&
+      path
+        .get('callee.object')
+        .isIdentifier({ name: loadableImportSpecifier }) &&
+      path.get('callee.property').isIdentifier({ name: 'lib' })
+    )
+  }
+
+  function hasLoadableComment(path) {
+    const comments = path.get('leadingComments')
+    const comment = comments.find(
+      ({ node }) =>
+        node && node.value && String(node.value).includes(LOADABLE_COMMENT),
+    )
+    if (!comment) return false
+    comment.remove()
+    return true
+  }
+
+  function getFuncPath(path) {
+    const funcPath = path.isCallExpression() ? path.get('arguments.0') : path
+    if (
+      !funcPath.isFunctionExpression() &&
+      !funcPath.isArrowFunctionExpression() &&
+      !funcPath.isObjectMethod()
+    ) {
+      return null
     }
+    return funcPath
+  }
 
-    function transformImport(path) {
-      const callPaths = collectImportCallPaths(path)
+  function transformImport(path) {
+    const callPaths = collectImportCallPaths(path)
 
-      // Ignore loadable function that does not have any "import" call
-      if (callPaths.length === 0) return
+    // Ignore loadable function that does not have any "import" call
+    if (callPaths.length === 0) return
 
-      // Multiple imports call is not supported
-      if (callPaths.length > 1) {
-        throw new Error(
-          'loadable: multiple import calls inside `loadable()` function are not supported.',
-        )
-      }
+    // Multiple imports call is not supported
+    if (callPaths.length > 1) {
+      throw new Error(
+        'loadable: multiple import calls inside `loadable()` function are not supported.',
+      )
+    }
 
-      const [callPath] = callPaths
+    const [callPath] = callPaths
 
-      const funcPath = getFuncPath(path)
-      if (!funcPath) return
+    const funcPath = getFuncPath(path)
+    if (!funcPath) return
 
-      funcPath.node.params = funcPath.node.params || []
+    funcPath.node.params = funcPath.node.params || []
 
-      const object = t.objectExpression(
-        propertyFactories.map(getProperty =>
-          getProperty({ path, callPath, funcPath }),
-        ),
-      )
+    const object = t.objectExpression(
+      propertyFactories.map(getProperty =>
+        getProperty({ path, callPath, funcPath }),
+      ),
+    )
 
-      if (funcPath.isObjectMethod()) {
-        funcPath.replaceWith(
-          t.objectProperty(funcPath.node.key, object, funcPath.node.computed),
-        )
-      } else {
-        funcPath.replaceWith(object)
-      }
+    if (funcPath.isObjectMethod()) {
+      funcPath.replaceWith(
+        t.objectProperty(funcPath.node.key, object, funcPath.node.computed),
+      )
+    } else {
+      funcPath.replaceWith(object)
     }
-
-    return {
-      inherits: syntaxDynamicImport,
-      visitor: {
-        Program: {
-          enter(programPath) {
-            let loadableImportSpecifier = defaultImportSpecifier
-            let lazyImportSpecifier = false
-
-            programPath.traverse({
-              ImportDefaultSpecifier(path) {
-                if (!loadableImportSpecifier) {
-                  const { parent } = path
-                  const { local } = path.node
-                  loadableImportSpecifier =
-                    parent.source.value == '@loadable/component' &&
-                    local &&
-                    local.name
-                }
-              },
-              ImportSpecifier(path) {
-                if (!lazyImportSpecifier) {
-                  const { parent } = path
-                  const { imported, local } = path.node
-                  lazyImportSpecifier =
-                    parent.source.value == '@loadable/component' &&
-                    imported &&
-                    imported.name == 'lazy' &&
-                    local &&
-                    local.name
-                }
-              },
-              CallExpression(path) {
-                if (
-                  !isValidIdentifier(
-                    path,
-                    loadableImportSpecifier,
-                    lazyImportSpecifier,
-                  )
+  }
+
+  return {
+    inherits: syntaxDynamicImport,
+    visitor: {
+      Program: {
+        enter(programPath) {
+          let loadableImportSpecifier = defaultImportSpecifier
+          let lazyImportSpecifier = false
+
+          programPath.traverse({
+            ImportDefaultSpecifier(path) {
+              if (!loadableImportSpecifier) {
+                const { parent } = path
+                const { local } = path.node
+                loadableImportSpecifier =
+                  parent.source.value == '@loadable/component' &&
+                  local &&
+                  local.name
+              }
+            },
+            ImportSpecifier(path) {
+              if (!lazyImportSpecifier) {
+                const { parent } = path
+                const { imported, local } = path.node
+                lazyImportSpecifier =
+                  parent.source.value == '@loadable/component' &&
+                  imported &&
+                  imported.name == 'lazy' &&
+                  local &&
+                  local.name
+              }
+            },
+            CallExpression(path) {
+              if (
+                !isValidIdentifier(
+                  path,
+                  loadableImportSpecifier,
+                  lazyImportSpecifier,
                 )
-                  return
-                transformImport(path)
-              },
-              'ArrowFunctionExpression|FunctionExpression|ObjectMethod': path => {
-                if (!hasLoadableComment(path)) return
-                transformImport(path)
-              },
-            })
-          },
+              )
+                return
+              transformImport(path)
+            },
+            'ArrowFunctionExpression|FunctionExpression|ObjectMethod': path => {
+              if (!hasLoadableComment(path)) return
+              transformImport(path)
+            },
+          })
         },
       },
-    }
-  },
-)
+    },
+  }
+})
 
 export default loadablePlugin

packages/babel-plugin/src/properties/resolve.js

@@ -1,11 +1,5 @@
 import { getImportArg } from '../util'
 
-/**
- *
- * @param {import('@babel/helper-plugin-utils').BabelAPI} api
- * @param {import('../index').LoadabelBabelPluginOptions} options
- * @returns {import('../index').PropertyFactory}
- */
 export default function resolveProperty(
   { types: t, template },
   { moduleFederation },
@@ -47,28 +41,8 @@ export default function resolveProperty(
     return t.stringLiteral(importArg.node.value)
   }
 
-  /**
-   * @type {import('../index').PropertyFactory}
-   */
-  const factory = (
-    /**
-     * @type {import('../index').PropertyFactoryOptions}
-     */
-    { callPath, funcPath, path },
-  ) => {
-    const properties = path.get('arguments.1.properties')
-
-    const isFederated =
-      moduleFederation ||
-      (Array.isArray(properties) &&
-        properties.some(
-          prop =>
-            prop.isObjectProperty() &&
-            prop.get('key').isIdentifier({ name: 'federated' }) &&
-            prop.get('value').isBooleanLiteral({ value: true }),
-        ))
-
-    const targetTemplate = isFederated ? 'federated' : 'standard'
+  return ({ callPath, funcPath }) => {
+    const targetTemplate = moduleFederation ? 'federated' : 'standard'
 
     return t.objectMethod(
       'method',
@@ -79,6 +53,4 @@ export default function resolveProperty(
       ),
     )
   }
-
-  return factory
 }